package com.sg.service.biz.pbff.impl;

import com.sg.common.exception.Assert;
import com.sg.common.util.RedisUtil;
import com.sg.dto.biz.pbff.req.*;
import com.sg.dto.biz.pbff.res.*;
import com.sg.dto.integration.calc.UpdateSingleEvaObjTarCycStaDataReqDto;
import com.sg.dto.integration.calc.UpdateSingleEvaObjTarCycStaDataRespDto;
import com.sg.dto.integration.framework.DeleteSpaceTestDataReqDto;
import com.sg.dto.integration.framework.DeleteSpaceTestDataRespDto;
import com.sg.service.biz.pbff.SystemTestDomainService;
import com.sg.service.biz.pbff.nb.NbSystemTestDomain;
import com.wicket.okrapp.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class SystemTestDomainServiceImpl implements SystemTestDomainService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    com.sg.service.biz.app.SystemTestDomainService fwAppSystemTestDomainClient;
    @Resource
    com.sg.service.biz.framework.DivineDataService fwBaseDivineDataClient;
    @Resource
    NbSystemTestDomain nbSystemTestDomain;
    @Resource
    com.sg.service.biz.calc.SystemTestDomainService fwCalcSystemTestDomainClient;
    @Resource
    com.sg.service.biz.framework.SystemTestDomainService fwBaseSystemTestDomainClient;

    /**
     * B3一键构造高中基层验证数据(管理)[4269]
     * gen by moon at 9/12/2022, 10:16:11 PM
     */
    @Trace(operationName = "B3一键构造高中基层验证数据(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildTopAndMidAndGrassRespDto autoBuildTopAndMidAndGrass(BffAutoBuildTopAndMidAndGrassReqDto reqDto) {


        //步骤0: D3-一键构造高中基层验证数据 - autoBuildTopAndMidAndGrass
        AutoBuildTopAndMidAndGrassRespDto autoBuildTopAndMidAndGrassRespDto = null;
        AutoBuildTopAndMidAndGrassReqDto autoBuildTopAndMidAndGrassReqDto = new AutoBuildTopAndMidAndGrassReqDto();
        if (reqDto != null) {
            autoBuildTopAndMidAndGrassReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//sourceId:284987_1
            autoBuildTopAndMidAndGrassReqDto.setIsFirst(reqDto.getIsFirst());//sourceId:269542_1
            autoBuildTopAndMidAndGrassReqDto.setTaskStatus(reqDto.getTaskStatus());//sourceId:304746_1
            autoBuildTopAndMidAndGrassReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:269543_1
            autoBuildTopAndMidAndGrassReqDto.setArchivngType(reqDto.getArchivngType());//sourceId:272991_1
            autoBuildTopAndMidAndGrassReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:269531_1
            autoBuildTopAndMidAndGrassReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:269532_1
            autoBuildTopAndMidAndGrassReqDto.setAppId(reqDto.getAppId());//sourceId:269533_1
        }

        /*D3-一键构造高中基层验证数据[4238]   */
        Assert.isNull(autoBuildTopAndMidAndGrassReqDto.getPeriodicModeTypeCode(), "B3一键构造高中基层验证数据(管理)-D3-一键构造高中基层验证数据-周期模式类型编码不能为空", false);
        autoBuildTopAndMidAndGrassRespDto = fwAppSystemTestDomainClient.autoBuildTopAndMidAndGrass(autoBuildTopAndMidAndGrassReqDto).getData();


        BffAutoBuildTopAndMidAndGrassRespDto retData = new BffAutoBuildTopAndMidAndGrassRespDto();


        return retData;
    }

    /**
     * B3-删除汇报任务相关数据（系统测试）[4312]
     * gen by moon at 8/31/2022, 5:42:20 PM
     */
    @Trace(operationName = "B3-删除汇报任务相关数据（系统测试）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffDeleteReportTaskRelatedDataRespDto deleteReportTaskRelatedData(BffDeleteReportTaskRelatedDataReqDto reqDto) {


        //步骤0: D3-删除汇报任务相关数据(公共) - deleteReportTaskRelatedDataCom
        DeleteReportTaskRelatedDataComRespDto deleteReportTaskRelatedDataComRespDto = null;
        DeleteReportTaskRelatedDataComReqDto deleteReportTaskRelatedDataComReqDto = new DeleteReportTaskRelatedDataComReqDto();
        if (reqDto != null) {
            deleteReportTaskRelatedDataComReqDto.setTaskId(reqDto.getTaskId());//sourceId:284974_1
        }

        /*D3-删除汇报任务相关数据(公共)[4211]   */
        Assert.isNull(deleteReportTaskRelatedDataComReqDto.getTaskId(), "B3-删除汇报任务相关数据（系统测试）-D3-删除汇报任务相关数据(公共)-任务ID不能为空", false);
        deleteReportTaskRelatedDataComRespDto = fwAppSystemTestDomainClient.deleteReportTaskRelatedDataCom(deleteReportTaskRelatedDataComReqDto).getData();


        BffDeleteReportTaskRelatedDataRespDto retData = new BffDeleteReportTaskRelatedDataRespDto();


        return retData;
    }

    /**
     * B3-一键删除评价模板数据[4311]
     * gen by moon at 6/11/2023, 6:51:27 AM
     */
    @Trace(operationName = "B3-一键删除评价模板数据")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffDeleteAddEvaTempDataRespDto deleteAddEvaTempData(BffDeleteAddEvaTempDataReqDto reqDto) {


        //步骤0: D3-一键删除评价模板验证数据(公共) - autoDeleteAddEvaTempDataCom
        AutoDeleteAddEvaTempDataComRespDto autoDeleteAddEvaTempDataComRespDto = null;
        AutoDeleteAddEvaTempDataComReqDto autoDeleteAddEvaTempDataComReqDto = new AutoDeleteAddEvaTempDataComReqDto();
        if (reqDto != null) {
            autoDeleteAddEvaTempDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1030494_1
            autoDeleteAddEvaTempDataComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:1032577_1
            autoDeleteAddEvaTempDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1032578_1
            autoDeleteAddEvaTempDataComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1032579_1
        }

        /*D3-一键删除评价模板验证数据(公共)[4207]   */
        Assert.isNull(autoDeleteAddEvaTempDataComReqDto.getEvaluationTemplateId(), "B3-一键删除评价模板数据-D3-一键删除评价模板验证数据(公共)-评价模板ID不能为空", false);
        Assert.isNull(autoDeleteAddEvaTempDataComReqDto.getCreateInductionId(), "B3-一键删除评价模板数据-D3-一键删除评价模板验证数据(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(autoDeleteAddEvaTempDataComReqDto.getSpaceId(), "B3-一键删除评价模板数据-D3-一键删除评价模板验证数据(公共)-创建于空间ID不能为空", false);
        Assert.isNull(autoDeleteAddEvaTempDataComReqDto.getAppId(), "B3-一键删除评价模板数据-D3-一键删除评价模板验证数据(公共)-创建于联盟应用ID不能为空", false);
        autoDeleteAddEvaTempDataComRespDto = fwAppSystemTestDomainClient.autoDeleteAddEvaTempDataCom(autoDeleteAddEvaTempDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffDeleteAddEvaTempDataRespDto retData = new BffDeleteAddEvaTempDataRespDto();


        return retData;
    }

    /**
     * B3一键删除汇报任务相关验证数据[4312]
     * gen by moon at 9/3/2022, 7:38:52 PM
     */
    @Trace(operationName = "B3一键删除汇报任务相关验证数据")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoDeleteReportTaskRelatedDataRespDto autoDeleteReportTaskRelatedData(BffAutoDeleteReportTaskRelatedDataReqDto reqDto) {


        //步骤0: D3-删除汇报任务相关数据(公共) - deleteReportTaskRelatedDataCom
        DeleteReportTaskRelatedDataComRespDto deleteReportTaskRelatedDataComRespDto = null;
        DeleteReportTaskRelatedDataComReqDto deleteReportTaskRelatedDataComReqDto = new DeleteReportTaskRelatedDataComReqDto();
        if (reqDto != null) {
            deleteReportTaskRelatedDataComReqDto.setTaskId(reqDto.getTaskId());//sourceId:284974_1
        }

        /*D3-删除汇报任务相关数据(公共)[4211]   */
        Assert.isNull(deleteReportTaskRelatedDataComReqDto.getTaskId(), "B3一键删除汇报任务相关验证数据-D3-删除汇报任务相关数据(公共)-任务ID不能为空", false);
        deleteReportTaskRelatedDataComRespDto = fwAppSystemTestDomainClient.deleteReportTaskRelatedDataCom(deleteReportTaskRelatedDataComReqDto).getData();


        BffAutoDeleteReportTaskRelatedDataRespDto retData = new BffAutoDeleteReportTaskRelatedDataRespDto();


        return retData;
    }

    /**
     * B3一键构造部门目标任务书验证数据[4378]
     * gen by moon at 9/12/2022, 10:16:13 PM
     */
    @Trace(operationName = "B3一键构造部门目标任务书验证数据")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildDepObjMisStaRespDto autoBuildDepObjMisSta(BffAutoBuildDepObjMisStaReqDto reqDto) {


        //步骤0: D3-构建部门目标任务书 - structureDepObjMisSta
        StructureDepObjMisStaRespDto structureDepObjMisStaRespDto = null;
        StructureDepObjMisStaReqDto structureDepObjMisStaReqDto = new StructureDepObjMisStaReqDto();
        structureDepObjMisStaReqDto.setDeptId("113643928233975808");//CUSTOM_CONVENTION//sourceId:306219_1
        structureDepObjMisStaReqDto.setEvaluationObjectId("126376802465103872");//CUSTOM_CONVENTION//sourceId:305536_1
        structureDepObjMisStaReqDto.setWeightValue(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:305540_1
        structureDepObjMisStaReqDto.setWeightScore(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:305541_1
        if (reqDto != null) {
            structureDepObjMisStaReqDto.setTargetId(reqDto.getTargetId());//sourceId:305537_1
            structureDepObjMisStaReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:305539_1
        }

        /*D3-构建部门目标任务书[4377]   */
        Assert.isNull(structureDepObjMisStaReqDto.getTargetId(), "B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-目标ID不能为空", false);
        Assert.isNull(structureDepObjMisStaReqDto.getSubjectLifeCycle(), "B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-主体生命周期不能为空", false);
        Assert.isNull(structureDepObjMisStaReqDto.getDeptId(), "B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-部门ID不能为空", false);
        Assert.isNull(structureDepObjMisStaReqDto.getEvaluationObjectId(), "B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-评价对象ID不能为空", false);
        Assert.isNull(structureDepObjMisStaReqDto.getWeightValue(), "B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-权重不能为空", false);
        Assert.isNull(structureDepObjMisStaReqDto.getWeightScore(), "B3一键构造部门目标任务书验证数据-D3-构建部门目标任务书-权重分值不能为空", false);
        structureDepObjMisStaRespDto = fwAppSystemTestDomainClient.structureDepObjMisSta(structureDepObjMisStaReqDto).getData();


        BffAutoBuildDepObjMisStaRespDto retData = new BffAutoBuildDepObjMisStaRespDto();


        return retData;
    }

    /**
     * B3一键重置高中基批次状态数据(管理)[4396]
     * gen by moon at 9/14/2022, 10:18:54 PM
     */
    @Trace(operationName = "B3一键重置高中基批次状态数据(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffBatchResetTopMidBatchDataRespDto batchResetTopMidBatchData(BffBatchResetTopMidBatchDataReqDto reqDto) {


        QueryTopMidBatchDataDetailRespDto queryTopMidBatchDataDetailRespDto_1 = null;
//步骤0: D3一键重置高中基批次状态数据 - batchResetTopMidBatchData
        BatchResetTopMidBatchDataRespDto batchResetTopMidBatchDataRespDto = null;
        BatchResetTopMidBatchDataReqDto batchResetTopMidBatchDataReqDto = new BatchResetTopMidBatchDataReqDto();
        if (reqDto != null) {
            batchResetTopMidBatchDataReqDto.setStatusCheckItemId(reqDto.getStatusCheckItemId());//sourceId:307105_1
            batchResetTopMidBatchDataReqDto.setNewBatchCode(reqDto.getNewBatchCode());//sourceId:323534_1
            batchResetTopMidBatchDataReqDto.setHistoryBatchCode(reqDto.getHistoryBatchCode());//sourceId:323535_1
            batchResetTopMidBatchDataReqDto.setIsFirst(reqDto.getIsFirst());//sourceId:307098_1
            batchResetTopMidBatchDataReqDto.setEvaTempStartMgtType(reqDto.getEvaTempStartMgtType());//sourceId:307097_1
            batchResetTopMidBatchDataReqDto.setBatchSetId(reqDto.getBatchSetId());//sourceId:307101_1
            batchResetTopMidBatchDataReqDto.setBatchSetObjectType(reqDto.getBatchSetObjectType());//sourceId:307102_1
            batchResetTopMidBatchDataReqDto.setCurrentManageObjectType(reqDto.getCurrentManageObjectType());//sourceId:307104_1
            batchResetTopMidBatchDataReqDto.setIsUnifiedMgt(reqDto.getIsUnifiedMgt());//sourceId:307103_1
        }

        /*D3一键重置高中基批次状态数据[4388]   */
        Assert.isNull(batchResetTopMidBatchDataReqDto.getStatusCheckItemId(), "B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-状态校验项ID不能为空", false);
        Assert.isNull(batchResetTopMidBatchDataReqDto.getNewBatchCode(), "B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-最新批次标识不能为空", false);
        Assert.isNull(batchResetTopMidBatchDataReqDto.getIsFirst(), "B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-是否首次批次不能为空", false);
        Assert.isNull(batchResetTopMidBatchDataReqDto.getEvaTempStartMgtType(), "B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-评价模板开始管理类型不能为空", false);
        Assert.isNull(batchResetTopMidBatchDataReqDto.getBatchSetId(), "B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-批次设置对象ID不能为空", false);
        Assert.isNull(batchResetTopMidBatchDataReqDto.getBatchSetObjectType(), "B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-批次设置对象类型不能为空", false);
        Assert.isNull(batchResetTopMidBatchDataReqDto.getIsUnifiedMgt(), "B3一键重置高中基批次状态数据(管理)-D3一键重置高中基批次状态数据-是否统一管理不能为空", false);
        batchResetTopMidBatchDataRespDto = fwAppSystemTestDomainClient.batchResetTopMidBatchData(batchResetTopMidBatchDataReqDto).getData();


//步骤1: D3-3查询高中基批次状态数据详情 - queryTopMidBatchDataDetail
        QueryTopMidBatchDataDetailRespDto queryTopMidBatchDataDetailRespDto = null;
        QueryTopMidBatchDataDetailReqDto queryTopMidBatchDataDetailReqDto = new QueryTopMidBatchDataDetailReqDto();
        if (reqDto != null) {
            queryTopMidBatchDataDetailReqDto.setNewBatchCode(reqDto.getNewBatchCode());//sourceId:323508_1
            queryTopMidBatchDataDetailReqDto.setHistoryBatchCode(reqDto.getHistoryBatchCode());//sourceId:323509_1
            queryTopMidBatchDataDetailReqDto.setStatusCheckItemId(reqDto.getStatusCheckItemId());//sourceId:310338_1
            queryTopMidBatchDataDetailReqDto.setBatchSetId(reqDto.getBatchSetId());//sourceId:310339_1
            queryTopMidBatchDataDetailReqDto.setBatchSetObjectType(reqDto.getBatchSetObjectType());//sourceId:310340_1
        }

        /*D3-3查询高中基批次状态数据详情[4408]   */
        Assert.isNull(queryTopMidBatchDataDetailReqDto.getNewBatchCode(), "B3一键重置高中基批次状态数据(管理)-D3-3查询高中基批次状态数据详情-最新批次标识不能为空", false);
        Assert.isNull(queryTopMidBatchDataDetailReqDto.getStatusCheckItemId(), "B3一键重置高中基批次状态数据(管理)-D3-3查询高中基批次状态数据详情-状态校验项ID不能为空", false);
        Assert.isNull(queryTopMidBatchDataDetailReqDto.getBatchSetId(), "B3一键重置高中基批次状态数据(管理)-D3-3查询高中基批次状态数据详情-批次设置对象ID不能为空", false);
        Assert.isNull(queryTopMidBatchDataDetailReqDto.getBatchSetObjectType(), "B3一键重置高中基批次状态数据(管理)-D3-3查询高中基批次状态数据详情-批次设置对象类型不能为空", false);
        queryTopMidBatchDataDetailRespDto = fwAppSystemTestDomainClient.queryTopMidBatchDataDetail(queryTopMidBatchDataDetailReqDto).getData();


        queryTopMidBatchDataDetailRespDto_1 = queryTopMidBatchDataDetailRespDto;

        BffBatchResetTopMidBatchDataRespDto retData = new BffBatchResetTopMidBatchDataRespDto();
        if (queryTopMidBatchDataDetailRespDto_1 != null) {
            retData.setNewBatchId(queryTopMidBatchDataDetailRespDto_1.getNewBatchId());//sourceId:323514_1
            retData.setNewBatchCode(queryTopMidBatchDataDetailRespDto_1.getNewBatchCode());//sourceId:329212_1
            retData.setNewIsFirst(queryTopMidBatchDataDetailRespDto_1.getNewIsFirst());//sourceId:310380_1
            retData.setNewIsNewbatch(queryTopMidBatchDataDetailRespDto_1.getNewIsNewbatch());//sourceId:310381_1
            retData.setNewSubjectLifeCycle(queryTopMidBatchDataDetailRespDto_1.getNewSubjectLifeCycle());//sourceId:310382_1
            retData.setNewIsArchive(queryTopMidBatchDataDetailRespDto_1.getNewIsArchive());//sourceId:310383_1
            retData.setNewIsEditing(queryTopMidBatchDataDetailRespDto_1.getNewIsEditing());//sourceId:310384_1
            retData.setBatchId(queryTopMidBatchDataDetailRespDto_1.getBatchId());//sourceId:323516_1
            retData.setBatchCode(queryTopMidBatchDataDetailRespDto_1.getBatchCode());//sourceId:329213_1
            retData.setIsFirst(queryTopMidBatchDataDetailRespDto_1.getIsFirst());//sourceId:310386_1
            retData.setIsNewbatch(queryTopMidBatchDataDetailRespDto_1.getIsNewbatch());//sourceId:310387_1
            retData.setSubjectLifeCycle(queryTopMidBatchDataDetailRespDto_1.getSubjectLifeCycle());//sourceId:310388_1
            retData.setIsArchive(queryTopMidBatchDataDetailRespDto_1.getIsArchive());//sourceId:310389_1
            retData.setIsEditing(queryTopMidBatchDataDetailRespDto_1.getIsEditing());//sourceId:310390_1
            retData.setBatchRelatedSetId(queryTopMidBatchDataDetailRespDto_1.getBatchRelatedSetId());//sourceId:310391_1
            retData.setBatchProcessProgress(queryTopMidBatchDataDetailRespDto_1.getBatchProcessProgress());//sourceId:310392_1
            retData.setDelBatchIsDone(queryTopMidBatchDataDetailRespDto_1.getDelBatchIsDone());//sourceId:310393_1
            retData.setCurrentManageObjectType(queryTopMidBatchDataDetailRespDto_1.getCurrentManageObjectType());//sourceId:310394_1
            retData.setManageLockStatus(queryTopMidBatchDataDetailRespDto_1.getManageLockStatus());//sourceId:310395_1
            retData.setReasonOfManageLock(queryTopMidBatchDataDetailRespDto_1.getReasonOfManageLock());//sourceId:310396_1
            retData.setReasonOfUsingLock(queryTopMidBatchDataDetailRespDto_1.getReasonOfUsingLock());//sourceId:310397_1
            retData.setUsingLockStatus(queryTopMidBatchDataDetailRespDto_1.getUsingLockStatus());//sourceId:310398_1
            retData.setIsUnifiedMgt(queryTopMidBatchDataDetailRespDto_1.getIsUnifiedMgt());//sourceId:310399_1
            retData.setStatusCheckItemId(queryTopMidBatchDataDetailRespDto_1.getStatusCheckItemId());//sourceId:310400_1
            retData.setIsComplete(queryTopMidBatchDataDetailRespDto_1.getIsComplete());//sourceId:310401_1
        }


        return retData;
    }

    /**
     * B3一键构造单条指标验证数据(管理)[4400]
     * gen by moon at 9/14/2022, 3:41:59 AM
     */
    @Trace(operationName = "B3一键构造单条指标验证数据(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildSingleTargetObjectiveRespDto autoBuildSingleTargetObjective(BffAutoBuildSingleTargetObjectiveReqDto reqDto) {


        AutoBuildSingleTargetObjectiveRespDto autoBuildSingleTargetObjectiveRespDto_1 = null;
//步骤0: D3一键构造单条指标验证数据 - autoBuildSingleTargetObjective
        AutoBuildSingleTargetObjectiveRespDto autoBuildSingleTargetObjectiveRespDto = null;
        AutoBuildSingleTargetObjectiveReqDto autoBuildSingleTargetObjectiveReqDto = new AutoBuildSingleTargetObjectiveReqDto();
        if (reqDto != null) {
            autoBuildSingleTargetObjectiveReqDto.setObjectiveName(reqDto.getObjectiveName());//sourceId:308616_1
            autoBuildSingleTargetObjectiveReqDto.setObjectiveShortName(reqDto.getObjectiveShortName());//sourceId:308617_1
            autoBuildSingleTargetObjectiveReqDto.setObjectiveCode(reqDto.getObjectiveCode());//sourceId:308618_1
            autoBuildSingleTargetObjectiveReqDto.setTargetType(reqDto.getTargetType());//sourceId:308619_1
            autoBuildSingleTargetObjectiveReqDto.setIsLastObjective(reqDto.getIsLastObjective());//sourceId:308621_1
            autoBuildSingleTargetObjectiveReqDto.setParentObjectiveId(reqDto.getParentObjectiveId());//sourceId:308622_1
            autoBuildSingleTargetObjectiveReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//sourceId:308623_1
            autoBuildSingleTargetObjectiveReqDto.setLevelNumber(reqDto.getLevelNumber());//sourceId:308624_1
            autoBuildSingleTargetObjectiveReqDto.setOrderNumber(reqDto.getOrderNumber());//sourceId:308625_1
            autoBuildSingleTargetObjectiveReqDto.setBatchCode(reqDto.getBatchCode());//sourceId:308614_1
            autoBuildSingleTargetObjectiveReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:308615_1
            autoBuildSingleTargetObjectiveReqDto.setRespBodyType(reqDto.getRespBodyType());//sourceId:320115_1
            autoBuildSingleTargetObjectiveReqDto.setDeptId(reqDto.getDeptId());//sourceId:320116_1
            autoBuildSingleTargetObjectiveReqDto.setVirtualOrgInductionRecordId(reqDto.getVirtualOrgInductionRecordId());//sourceId:320117_1
            autoBuildSingleTargetObjectiveReqDto.setRoleCode(reqDto.getRoleCode());//sourceId:320118_1
        }

        /*D3一键构造单条指标验证数据[4397]   */
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getObjectiveName(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-指标名称不能为空", false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getObjectiveShortName(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-指标简称不能为空", false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getObjectiveCode(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-指标标识不能为空", false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getTargetType(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-目标类型不能为空", false);
//Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getIsUseFirstDept(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-是否用于一级部门不能为空",false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getIsLastObjective(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-是否末级指标不能为空", false);
//Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getParentObjectiveId(),"B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-归属父级指标ID不能为空",false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getPeriodicModeTypeCode(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-周期模式类型编码不能为空", false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getLevelNumber(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-层级不能为空", false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getOrderNumber(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-排序不能为空", false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getBatchCode(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-批次标识不能为空", false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getSubjectLifeCycle(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-主体生命周期不能为空", false);
        Assert.isNull(autoBuildSingleTargetObjectiveReqDto.getRespBodyType(), "B3一键构造单条指标验证数据(管理)-D3一键构造单条指标验证数据-责任主体类型不能为空", false);
        autoBuildSingleTargetObjectiveRespDto = fwAppSystemTestDomainClient.autoBuildSingleTargetObjective(autoBuildSingleTargetObjectiveReqDto).getData();


        autoBuildSingleTargetObjectiveRespDto_1 = autoBuildSingleTargetObjectiveRespDto;

        BffAutoBuildSingleTargetObjectiveRespDto retData = new BffAutoBuildSingleTargetObjectiveRespDto();
        if (autoBuildSingleTargetObjectiveRespDto_1 != null) {
            retData.setObjectiveId(autoBuildSingleTargetObjectiveRespDto_1.getObjectiveId());//sourceId:308646_1
        }


        return retData;
    }

    /**
     * B3一键构造单条被评对象目标周期验证数据[4411]
     * gen by moon at 9/12/2022, 10:16:14 PM
     */
    @Trace(operationName = "B3一键构造单条被评对象目标周期验证数据")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildSingleEvaObjTarCycRespDto autoBuildSingleEvaObjTarCyc(BffAutoBuildSingleEvaObjTarCycReqDto reqDto) {


        AutoBuildSingleEvaObjTarCycRespDto autoBuildSingleEvaObjTarCycRespDto_1 = null;
//步骤0: D3一键构造单条被评对象目标周期验证数据 - autoBuildSingleEvaObjTarCyc
        AutoBuildSingleEvaObjTarCycRespDto autoBuildSingleEvaObjTarCycRespDto = null;
        AutoBuildSingleEvaObjTarCycReqDto autoBuildSingleEvaObjTarCycReqDto = new AutoBuildSingleEvaObjTarCycReqDto();
        if (reqDto != null) {
            autoBuildSingleEvaObjTarCycReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//sourceId:310730_1
            autoBuildSingleEvaObjTarCycReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//sourceId:310731_1
            autoBuildSingleEvaObjTarCycReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//sourceId:310732_1
            autoBuildSingleEvaObjTarCycReqDto.setTreeTypeCode(reqDto.getTreeTypeCode());//sourceId:310733_1
            autoBuildSingleEvaObjTarCycReqDto.setSuperiorTargetCycleContentTypeCode(reqDto.getSuperiorTargetCycleContentTypeCode());//sourceId:310734_1
            autoBuildSingleEvaObjTarCycReqDto.setSuperiorTargetCycleContentId(reqDto.getSuperiorTargetCycleContentId());//sourceId:310735_1
            autoBuildSingleEvaObjTarCycReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//sourceId:310736_1
            autoBuildSingleEvaObjTarCycReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//sourceId:310737_1
            autoBuildSingleEvaObjTarCycReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//sourceId:310738_1
            autoBuildSingleEvaObjTarCycReqDto.setTaskStatus(reqDto.getTaskStatus());//sourceId:310739_1
            autoBuildSingleEvaObjTarCycReqDto.setLogicalOperator(reqDto.getLogicalOperator());//sourceId:310740_1
            autoBuildSingleEvaObjTarCycReqDto.setTargetDiagnosticValue(reqDto.getTargetDiagnosticValue());//sourceId:310741_1
            autoBuildSingleEvaObjTarCycReqDto.setWeightScore(reqDto.getWeightScore());//sourceId:310742_1
            autoBuildSingleEvaObjTarCycReqDto.setWeightValue(reqDto.getWeightValue());//sourceId:310743_1
        }

        /*D3一键构造单条被评对象目标周期验证数据[4410]   */
        Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getEvaObjEntityId(), "B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-被评对象内容表主键ID不能为空", false);
        Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getEvaObjTableTypeCode(), "B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-被评对象内容表类型编码不能为空", false);
        Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getEvaObjTypeCode(), "B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-被评对象类型编码不能为空", false);
        Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getTreeTypeCode(), "B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-树类型编码不能为空", false);
        Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getTargetCycleContentTypeCode(), "B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-关联目标内容类型编码不能为空", false);
        Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getTargetCycleContentId(), "B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-关联目标内容ID不能为空", false);
        Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getEvaluationTemplateId(), "B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-评价模板ID不能为空", false);
        Assert.isNull(autoBuildSingleEvaObjTarCycReqDto.getTaskStatus(), "B3一键构造单条被评对象目标周期验证数据-D3一键构造单条被评对象目标周期验证数据-目标周期任务进展状态不能为空", false);
        autoBuildSingleEvaObjTarCycRespDto = fwAppSystemTestDomainClient.autoBuildSingleEvaObjTarCyc(autoBuildSingleEvaObjTarCycReqDto).getData();


        autoBuildSingleEvaObjTarCycRespDto_1 = autoBuildSingleEvaObjTarCycRespDto;

        BffAutoBuildSingleEvaObjTarCycRespDto retData = new BffAutoBuildSingleEvaObjTarCycRespDto();
        if (autoBuildSingleEvaObjTarCycRespDto_1 != null) {
            retData.setEvaObjTargetCycleId(autoBuildSingleEvaObjTarCycRespDto_1.getEvaObjTargetCycleId());//sourceId:313461_1
        }


        return retData;
    }

    /**
     * B3一键删除单条指标验证数据(管理)[4415]
     * gen by moon at 9/7/2022, 1:50:03 AM
     */
    @Trace(operationName = "B3一键删除单条指标验证数据(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoDeleteSingleTargetObjectiveRespDto autoDeleteSingleTargetObjective(BffAutoDeleteSingleTargetObjectiveReqDto reqDto) {


        //步骤0: D3一键删除单条指标验证数据 - autoDeleteSingleTargetObjective
        AutoDeleteSingleTargetObjectiveRespDto autoDeleteSingleTargetObjectiveRespDto = null;
        AutoDeleteSingleTargetObjectiveReqDto autoDeleteSingleTargetObjectiveReqDto = new AutoDeleteSingleTargetObjectiveReqDto();
        if (reqDto != null) {
            autoDeleteSingleTargetObjectiveReqDto.setObjectiveId(reqDto.getObjectiveId());//sourceId:312516_1
        }

        /*D3一键删除单条指标验证数据[4413]   */
        Assert.isNull(autoDeleteSingleTargetObjectiveReqDto.getObjectiveId(), "B3一键删除单条指标验证数据(管理)-D3一键删除单条指标验证数据-指标ID不能为空", false);
        autoDeleteSingleTargetObjectiveRespDto = fwAppSystemTestDomainClient.autoDeleteSingleTargetObjective(autoDeleteSingleTargetObjectiveReqDto).getData();


        BffAutoDeleteSingleTargetObjectiveRespDto retData = new BffAutoDeleteSingleTargetObjectiveRespDto();


        return retData;
    }

    /**
     * B3一键删除单条被评对象目标周期验证数据(管理)[4416]
     * gen by moon at 9/7/2022, 1:50:05 AM
     */
    @Trace(operationName = "B3一键删除单条被评对象目标周期验证数据(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoDeleteSingleEvaObjTarCycRespDto autoDeleteSingleEvaObjTarCyc(BffAutoDeleteSingleEvaObjTarCycReqDto reqDto) {


        //步骤0: D3-3-09删除单条被评对象目标周期(公共) - deleteSingleEvaObjTarCycCom
        DeleteSingleEvaObjTarCycComRespDto deleteSingleEvaObjTarCycComRespDto = null;
        DeleteSingleEvaObjTarCycComReqDto deleteSingleEvaObjTarCycComReqDto = new DeleteSingleEvaObjTarCycComReqDto();
        if (reqDto != null) {
            deleteSingleEvaObjTarCycComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//sourceId:312514_1
        }

        /*D3-3-09删除单条被评对象目标周期(公共)[4443]   */
        Assert.isNull(deleteSingleEvaObjTarCycComReqDto.getEvaObjTargetCycleId(), "B3一键删除单条被评对象目标周期验证数据(管理)-D3-3-09删除单条被评对象目标周期(公共)-被评对象目标周期ID不能为空", false);
        deleteSingleEvaObjTarCycComRespDto = fwAppSystemTestDomainClient.deleteSingleEvaObjTarCycCom(deleteSingleEvaObjTarCycComReqDto).getData();


        BffAutoDeleteSingleEvaObjTarCycRespDto retData = new BffAutoDeleteSingleEvaObjTarCycRespDto();


        return retData;
    }

    /**
     * B3一键构造父子状态检查项等测试验证数据（真实接口）[4477]
     * gen by moon at 10/20/2022, 10:07:01 AM
     */
    @Trace(operationName = "B3一键构造父子状态检查项等测试验证数据（真实接口）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildAssistNnodeStatusEtcTestRespDto autoBuildAssistNnodeStatusEtcTest(BffAutoBuildAssistNnodeStatusEtcTestReqDto reqDto) {


        //步骤0: D3一键构造父子状态检查项等测试验证数据 - autoBuildAssistNnodeStatusEtcTest
        AutoBuildAssistNnodeStatusEtcTestRespDto autoBuildAssistNnodeStatusEtcTestRespDto = null;
        AutoBuildAssistNnodeStatusEtcTestReqDto autoBuildAssistNnodeStatusEtcTestReqDto = new AutoBuildAssistNnodeStatusEtcTestReqDto();
        if (reqDto != null) {
            autoBuildAssistNnodeStatusEtcTestReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:374038_1
            autoBuildAssistNnodeStatusEtcTestReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:374039_1
            autoBuildAssistNnodeStatusEtcTestReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:374040_1
        }

        /*D3一键构造父子状态检查项等测试验证数据[4478]   */
        Assert.isNull(autoBuildAssistNnodeStatusEtcTestReqDto.getEvaluationTemplateId(), "B3一键构造父子状态检查项等测试验证数据（真实接口）-D3一键构造父子状态检查项等测试验证数据-冗余评价模板ID不能为空", false);
        Assert.isNull(autoBuildAssistNnodeStatusEtcTestReqDto.getTableTypeCode(), "B3一键构造父子状态检查项等测试验证数据（真实接口）-D3一键构造父子状态检查项等测试验证数据-内容表类型编码不能为空", false);
        Assert.isNull(autoBuildAssistNnodeStatusEtcTestReqDto.getEntityId(), "B3一键构造父子状态检查项等测试验证数据（真实接口）-D3一键构造父子状态检查项等测试验证数据-内容表主键ID不能为空", false);
        autoBuildAssistNnodeStatusEtcTestRespDto = fwAppSystemTestDomainClient.autoBuildAssistNnodeStatusEtcTest(autoBuildAssistNnodeStatusEtcTestReqDto).getData();


        BffAutoBuildAssistNnodeStatusEtcTestRespDto retData = new BffAutoBuildAssistNnodeStatusEtcTestRespDto();


        return retData;
    }

    /**
     * B3-一键构造状态检查项验证数据（管理）[4481]
     * gen by moon at 9/8/2022, 4:07:23 AM
     */
    @Trace(operationName = "B3-一键构造状态检查项验证数据（管理）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildStatusCheckItemRespDto autoBuildStatusCheckItem(BffAutoBuildStatusCheckItemReqDto reqDto) {


        AutoBuildStatusCheckItemTestRespDto autoBuildStatusCheckItemTestRespDto_1 = null;
//步骤0: D3一键构造检查项状态测试验证数据 - autoBuildStatusCheckItemTest
        AutoBuildStatusCheckItemTestRespDto autoBuildStatusCheckItemTestRespDto = null;
        AutoBuildStatusCheckItemTestReqDto autoBuildStatusCheckItemTestReqDto = new AutoBuildStatusCheckItemTestReqDto();
        if (reqDto != null) {
            autoBuildStatusCheckItemTestReqDto.setEntityId(reqDto.getEntityId());//sourceId:313350_1
            autoBuildStatusCheckItemTestReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:313351_1
            autoBuildStatusCheckItemTestReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:313352_1
            autoBuildStatusCheckItemTestReqDto.setUpdateStatusCheckItemId(reqDto.getUpdateStatusCheckItemId());//sourceId:313701_1
            autoBuildStatusCheckItemTestReqDto.setIsComplete(reqDto.getIsComplete());//sourceId:313354_1
            autoBuildStatusCheckItemTestReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:313355_1
            autoBuildStatusCheckItemTestReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:313356_1
            autoBuildStatusCheckItemTestReqDto.setAppId(reqDto.getAppId());//sourceId:313357_1
        }

        /*D3一键构造检查项状态测试验证数据[4482]   */
        Assert.isNull(autoBuildStatusCheckItemTestReqDto.getCreateInductionId(), "B3-一键构造状态检查项验证数据（管理）-D3一键构造检查项状态测试验证数据-创建人就职记录ID 不能为空", false);
        Assert.isNull(autoBuildStatusCheckItemTestReqDto.getSpaceId(), "B3-一键构造状态检查项验证数据（管理）-D3一键构造检查项状态测试验证数据-创建于空间ID不能为空", false);
        Assert.isNull(autoBuildStatusCheckItemTestReqDto.getAppId(), "B3-一键构造状态检查项验证数据（管理）-D3一键构造检查项状态测试验证数据-创建于联盟应用ID不能为空", false);
        autoBuildStatusCheckItemTestRespDto = fwAppSystemTestDomainClient.autoBuildStatusCheckItemTest(autoBuildStatusCheckItemTestReqDto).getData();


        autoBuildStatusCheckItemTestRespDto_1 = autoBuildStatusCheckItemTestRespDto;

        BffAutoBuildStatusCheckItemRespDto retData = new BffAutoBuildStatusCheckItemRespDto();
        if (autoBuildStatusCheckItemTestRespDto_1 != null) {
            retData.setStatusCheckItemId(autoBuildStatusCheckItemTestRespDto_1.getStatusCheckItemId());//sourceId:313366_1
        }


        return retData;
    }

    /**
     * B3-一键构造检查仪表盘测试验证数据（管理）[4490]
     * gen by moon at 9/8/2022, 4:07:24 AM
     */
    @Trace(operationName = "B3-一键构造检查仪表盘测试验证数据（管理）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildAssistCheckPanelTestRespDto autoBuildAssistCheckPanelTest(BffAutoBuildAssistCheckPanelTestReqDto reqDto) {


        AutoBuildAssistCheckPanelTestRespDto autoBuildAssistCheckPanelTestRespDto_1 = null;
//步骤0: D3-一键构造检查仪表盘测试验证数据 - autoBuildAssistCheckPanelTest
        AutoBuildAssistCheckPanelTestRespDto autoBuildAssistCheckPanelTestRespDto = null;
        AutoBuildAssistCheckPanelTestReqDto autoBuildAssistCheckPanelTestReqDto = new AutoBuildAssistCheckPanelTestReqDto();
        if (reqDto != null) {
            autoBuildAssistCheckPanelTestReqDto.setCheckObjectTypeCode(reqDto.getCheckObjectTypeCode());//sourceId:313678_1
            autoBuildAssistCheckPanelTestReqDto.setCheckObjectTypeId(reqDto.getCheckObjectTypeId());//sourceId:313679_1
            autoBuildAssistCheckPanelTestReqDto.setCheckItemCode(reqDto.getCheckItemCode());//sourceId:313680_1
            autoBuildAssistCheckPanelTestReqDto.setTargetValue(reqDto.getTargetValue());//sourceId:313681_1
            autoBuildAssistCheckPanelTestReqDto.setActualValue(reqDto.getActualValue());//sourceId:313682_1
            autoBuildAssistCheckPanelTestReqDto.setUpdateCheckItemPanelUpdateId(reqDto.getUpdateCheckItemPanelUpdateId());//sourceId:313683_1
            autoBuildAssistCheckPanelTestReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:313684_1
            autoBuildAssistCheckPanelTestReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:313685_1
            autoBuildAssistCheckPanelTestReqDto.setAppId(reqDto.getAppId());//sourceId:313686_1
        }

        /*D3-一键构造检查仪表盘测试验证数据[4491]   */
        Assert.isNull(autoBuildAssistCheckPanelTestReqDto.getCreateInductionId(), "B3-一键构造检查仪表盘测试验证数据（管理）-D3-一键构造检查仪表盘测试验证数据-创建人就职记录ID 不能为空", false);
        Assert.isNull(autoBuildAssistCheckPanelTestReqDto.getSpaceId(), "B3-一键构造检查仪表盘测试验证数据（管理）-D3-一键构造检查仪表盘测试验证数据-创建于空间ID不能为空", false);
        Assert.isNull(autoBuildAssistCheckPanelTestReqDto.getAppId(), "B3-一键构造检查仪表盘测试验证数据（管理）-D3-一键构造检查仪表盘测试验证数据-创建于联盟应用ID不能为空", false);
        autoBuildAssistCheckPanelTestRespDto = fwAppSystemTestDomainClient.autoBuildAssistCheckPanelTest(autoBuildAssistCheckPanelTestReqDto).getData();


        autoBuildAssistCheckPanelTestRespDto_1 = autoBuildAssistCheckPanelTestRespDto;

        BffAutoBuildAssistCheckPanelTestRespDto retData = new BffAutoBuildAssistCheckPanelTestRespDto();
        if (autoBuildAssistCheckPanelTestRespDto_1 != null) {
            retData.setCheckItemPanelUpdateId(autoBuildAssistCheckPanelTestRespDto_1.getCheckItemPanelUpdateId());//sourceId:313698_1
        }


        return retData;
    }

    /**
     * B3一键构造单条目标分类验证数据(管理）[4318]
     * gen by moon at 9/14/2022, 3:41:57 AM
     */
    @Trace(operationName = "B3一键构造单条目标分类验证数据(管理）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildSingleTargetCategoryRespDto autoBuildSingleTargetCategory(BffAutoBuildSingleTargetCategoryReqDto reqDto) {


        AutoBuildSingleTargetCategoryRespDto autoBuildSingleTargetCategoryRespDto_1 = null;
//步骤0: D3-一键构造单条目标分类验证数据 - autoBuildSingleTargetCategory
        AutoBuildSingleTargetCategoryRespDto autoBuildSingleTargetCategoryRespDto = null;
        AutoBuildSingleTargetCategoryReqDto autoBuildSingleTargetCategoryReqDto = new AutoBuildSingleTargetCategoryReqDto();
        if (reqDto != null) {
            autoBuildSingleTargetCategoryReqDto.setTargetCategoryCode(reqDto.getTargetCategoryCode());//sourceId:317471_1
            autoBuildSingleTargetCategoryReqDto.setTargetCategoryName(reqDto.getTargetCategoryName());//sourceId:317477_1
            autoBuildSingleTargetCategoryReqDto.setTargetCategoryDescribe(reqDto.getTargetCategoryDescribe());//sourceId:317478_1
            autoBuildSingleTargetCategoryReqDto.setTargetCategoryRemarks(reqDto.getTargetCategoryRemarks());//sourceId:317479_1
            autoBuildSingleTargetCategoryReqDto.setParentTtargetCategoryId(reqDto.getParentTtargetCategoryId());//sourceId:317472_1
            autoBuildSingleTargetCategoryReqDto.setRootTargetCategoryId(reqDto.getRootTargetCategoryId());//sourceId:317480_1
            autoBuildSingleTargetCategoryReqDto.setIsLast(reqDto.getIsLast());//sourceId:317473_1
            autoBuildSingleTargetCategoryReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//sourceId:317474_1
            autoBuildSingleTargetCategoryReqDto.setReportObjectSetCode(reqDto.getReportObjectSetCode());//sourceId:317484_1
            autoBuildSingleTargetCategoryReqDto.setLevelNumber(reqDto.getLevelNumber());//sourceId:317475_1
            autoBuildSingleTargetCategoryReqDto.setOrderNumber(reqDto.getOrderNumber());//sourceId:317476_1
            autoBuildSingleTargetCategoryReqDto.setBatchCode(reqDto.getBatchCode());//sourceId:317469_1
            autoBuildSingleTargetCategoryReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:317470_1
            autoBuildSingleTargetCategoryReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:317467_1
            autoBuildSingleTargetCategoryReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:317466_1
            autoBuildSingleTargetCategoryReqDto.setAppId(reqDto.getAppId());//sourceId:317468_1
            autoBuildSingleTargetCategoryReqDto.setVirtualOrgInductionRecordId(reqDto.getVirtualOrgInductionRecordId());//sourceId:317481_1
            autoBuildSingleTargetCategoryReqDto.setRoleCode(reqDto.getRoleCode());//sourceId:317483_1
            autoBuildSingleTargetCategoryReqDto.setDeptId(reqDto.getDeptId());//sourceId:317482_1
        }

        /*D3-一键构造单条目标分类验证数据[4319]   */
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getTargetCategoryCode(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-目标分类标识不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getTargetCategoryName(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-目标分类名称不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getIsLast(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-目标分类是否末级不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getPeriodicModeTypeCode(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-周期模式类型编码不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getReportObjectSetCode(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-建设任务汇报对象设置项编码不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getLevelNumber(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-层级不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getOrderNumber(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-排序不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getBatchCode(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-批次标识不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getSubjectLifeCycle(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-主体生命周期不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getCreateInductionId(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-创建人就职记录ID 不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getSpaceId(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-创建于空间ID不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getAppId(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-创建于联盟应用ID不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getVirtualOrgInductionRecordId(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-负责人就职记录ID不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getRoleCode(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-负责人角色标识不能为空", false);
        Assert.isNull(autoBuildSingleTargetCategoryReqDto.getDeptId(), "B3一键构造单条目标分类验证数据(管理）-D3-一键构造单条目标分类验证数据-牵头部门ID不能为空", false);
        autoBuildSingleTargetCategoryRespDto = fwAppSystemTestDomainClient.autoBuildSingleTargetCategory(autoBuildSingleTargetCategoryReqDto).getData();


        autoBuildSingleTargetCategoryRespDto_1 = autoBuildSingleTargetCategoryRespDto;

        BffAutoBuildSingleTargetCategoryRespDto retData = new BffAutoBuildSingleTargetCategoryRespDto();
        if (autoBuildSingleTargetCategoryRespDto_1 != null) {
            retData.setTargetCategoryId(autoBuildSingleTargetCategoryRespDto_1.getTargetCategoryId());//sourceId:317506_1
        }


        return retData;
    }

    /**
     * B3一键删除单条目标分类验证数据(管理)[4510]
     * gen by moon at 11/4/2022, 7:39:28 AM
     */
    @Trace(operationName = "B3一键删除单条目标分类验证数据(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoDeleteSingleTargetCategoryRespDto autoDeleteSingleTargetCategory(BffAutoDeleteSingleTargetCategoryReqDto reqDto) {


        //步骤0: D3一键删除单条目标分类验证数据(公共) - autoDeleteSingleTargetCategoryCom
        AutoDeleteSingleTargetCategoryComRespDto autoDeleteSingleTargetCategoryComRespDto = null;
        AutoDeleteSingleTargetCategoryComReqDto autoDeleteSingleTargetCategoryComReqDto = new AutoDeleteSingleTargetCategoryComReqDto();
        if (reqDto != null) {
            autoDeleteSingleTargetCategoryComReqDto.setTargetCategoryId(reqDto.getTargetCategoryId());//SimpleFieldAssign//sourceId:317545_1
        }

        /*D3一键删除单条目标分类验证数据(公共)[4509]   */
        Assert.isNull(autoDeleteSingleTargetCategoryComReqDto.getTargetCategoryId(), "B3一键删除单条目标分类验证数据(管理)-D3一键删除单条目标分类验证数据(公共)-目标分类ID不能为空", false);
        autoDeleteSingleTargetCategoryComRespDto = fwAppSystemTestDomainClient.autoDeleteSingleTargetCategoryCom(autoDeleteSingleTargetCategoryComReqDto).getData();


        BffAutoDeleteSingleTargetCategoryRespDto retData = new BffAutoDeleteSingleTargetCategoryRespDto();


        return retData;
    }

    /**
     * B3一键构造单条被评对象目标周期标准数据验证数据[4502]
     * gen by moon at 10/17/2022, 6:42:05 PM
     */
    @Trace(operationName = "B3一键构造单条被评对象目标周期标准数据验证数据")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildSingleEvaObjTarCycStaDataRespDto autoBuildSingleEvaObjTarCycStaData(BffAutoBuildSingleEvaObjTarCycStaDataReqDto reqDto) {


        //步骤0: D3-3查询单条目标详情 - querySingleTargetDetail
        QuerySingleTargetDetailRespDto querySingleTargetDetailRespDto = null;
        QuerySingleTargetDetailReqDto querySingleTargetDetailReqDto = new QuerySingleTargetDetailReqDto();
        if (reqDto != null) {
            querySingleTargetDetailReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:317410_1
        }

        /*D3-3查询单条目标详情[3576]   */
        Assert.isNull(querySingleTargetDetailReqDto.getTargetId(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-3查询单条目标详情-目标ID不能为空", false);
        querySingleTargetDetailRespDto = fwAppSystemTestDomainClient.querySingleTargetDetail(querySingleTargetDetailReqDto).getData();


//步骤1: D3-推送业务应用公共字段缓存测试(公共) - putAppPublicFieldCacheCom
        //ModelCode: publicFieldCache
        PutAppPublicFieldCacheComRespDto publicFieldCacheRes = null;
        if (querySingleTargetDetailRespDto != null) {
            com.wicket.okrpbff.biz.service.dto.req.PutAppPublicFieldCacheComReqDto publicFieldCacheReq = new PutAppPublicFieldCacheComReqDto();
            if (querySingleTargetDetailRespDto != null) {
                publicFieldCacheReq.setCreateInductionId(querySingleTargetDetailRespDto.getCreateInductionId());//SimpleFieldAssign//sourceId:318921_1
                publicFieldCacheReq.setSpaceId(querySingleTargetDetailRespDto.getSpaceId());//SimpleFieldAssign//sourceId:318922_1
                publicFieldCacheReq.setAppId(querySingleTargetDetailRespDto.getAppId());//SimpleFieldAssign//sourceId:318923_1
            }

            /*D3-推送业务应用公共字段缓存测试(公共)[4523]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
            Assert.isNull(publicFieldCacheReq.getCreateInductionId(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-推送业务应用公共字段缓存测试(公共)-创建人就职记录ID 不能为空", false);
            Assert.isNull(publicFieldCacheReq.getSpaceId(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-推送业务应用公共字段缓存测试(公共)-创建于空间ID不能为空", false);
            Assert.isNull(publicFieldCacheReq.getAppId(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-推送业务应用公共字段缓存测试(公共)-创建于联盟应用ID不能为空", false);
            publicFieldCacheRes = nbSystemTestDomain.putAppPublicFieldCacheCom(publicFieldCacheReq);


        }

//步骤2: D3-一键构造被评对象目标周期标准数据验证数据(公共) - autoBuildEvaObjTarCycStaDataCom
        AutoBuildEvaObjTarCycStaDataComRespDto autoBuildEvaObjTarCycStaDataComRespDto = null;
        AutoBuildEvaObjTarCycStaDataComReqDto autoBuildEvaObjTarCycStaDataComReqDto = new AutoBuildEvaObjTarCycStaDataComReqDto();
        autoBuildEvaObjTarCycStaDataComReqDto.setBizRoleObjCode("PRINCIPAL");//CUSTOM_CONVENTION//sourceId:317036_1
        autoBuildEvaObjTarCycStaDataComReqDto.setPersonLiableTypeCode("FILL_ROLE");//sourceId:317037_1
        autoBuildEvaObjTarCycStaDataComReqDto.setBizRoleObjName("PRINCIPAL");//CUSTOM_CONVENTION//sourceId:317038_1
        autoBuildEvaObjTarCycStaDataComReqDto.setProgressValueUnit("PERCENT");//sourceId:317020_1
        autoBuildEvaObjTarCycStaDataComReqDto.setProgressFromLastRatioUnit("PERCENT");//sourceId:317022_1
        autoBuildEvaObjTarCycStaDataComReqDto.setReachUnit("PERCENT");//sourceId:317026_1
        autoBuildEvaObjTarCycStaDataComReqDto.setActualFromLastTimeRatioUnit("PERCENT");//sourceId:317028_1
        autoBuildEvaObjTarCycStaDataComReqDto.setRealTimeScoreUnit("FEN");//CUSTOM_CONVENTION//sourceId:317030_1
        autoBuildEvaObjTarCycStaDataComReqDto.setStageData("抽查计算机学院课程进度，目前进度正常，课程思政元素目前是做开放课程必要的前提，主要是课程标准的设计，把思政中立德树人放在第一位，主要是课程标准的设计");//CUSTOM_CONVENTION//sourceId:317042_1
        autoBuildEvaObjTarCycStaDataComReqDto.setSummaryDataPic("http://www.suzhi.link/SPACE/REPORT_THUMBNAIL/DEFAULT/20220829/D5A394AB9E6F4A8EBFB1890EF48A21DF.jpeg");//CUSTOM_CONVENTION//sourceId:317043_1
        autoBuildEvaObjTarCycStaDataComReqDto.setTextSummaryData("发起目标沟通会，确定各部门的目标任务，以及确定验收标准。");//CUSTOM_CONVENTION//sourceId:317044_1
        if (reqDto != null) {
            autoBuildEvaObjTarCycStaDataComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:317031_1
            autoBuildEvaObjTarCycStaDataComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:317047_1
            autoBuildEvaObjTarCycStaDataComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:317041_1
            autoBuildEvaObjTarCycStaDataComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:317039_1
            autoBuildEvaObjTarCycStaDataComReqDto.setTreeTypeCode(reqDto.getTreeTypeCode());//SimpleFieldAssign//sourceId:317040_1
            autoBuildEvaObjTarCycStaDataComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:317033_1
            autoBuildEvaObjTarCycStaDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:317032_1
            autoBuildEvaObjTarCycStaDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:317034_1
            autoBuildEvaObjTarCycStaDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:317035_1
            autoBuildEvaObjTarCycStaDataComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:317023_1
            autoBuildEvaObjTarCycStaDataComReqDto.setActualValueUnit(reqDto.getActualValueUnit());//SimpleFieldAssign//sourceId:317024_1
            autoBuildEvaObjTarCycStaDataComReqDto.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:317019_1
            autoBuildEvaObjTarCycStaDataComReqDto.setProgressFromLastRatio(reqDto.getProgressFromLastRatio());//SimpleFieldAssign//sourceId:317021_1
            autoBuildEvaObjTarCycStaDataComReqDto.setReach(reqDto.getReach());//SimpleFieldAssign//sourceId:317025_1
            autoBuildEvaObjTarCycStaDataComReqDto.setActualFromLastTimeRatio(reqDto.getActualFromLastTimeRatio());//SimpleFieldAssign//sourceId:317027_1
            autoBuildEvaObjTarCycStaDataComReqDto.setRealTimeScore(reqDto.getRealTimeScore());//SimpleFieldAssign//sourceId:317029_1
            autoBuildEvaObjTarCycStaDataComReqDto.setFilledByInductionId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:317045_1
            autoBuildEvaObjTarCycStaDataComReqDto.setEvaluationFillRoleId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:317046_1
        }

        /*D3-一键构造被评对象目标周期标准数据验证数据(公共)[4294]   */
        Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getProgressValueUnit(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-进度值单位不能为空", false);
        Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getProgressFromLastRatioUnit(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-进度较上次增降幅单位不能为空", false);
        Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getReachUnit(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-达成度单位不能为空", false);
        Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getActualFromLastTimeRatioUnit(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-达成度较上次增降福单位不能为空", false);
        Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getRealTimeScoreUnit(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-实时得分单位不能为空", false);
        Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getStageData(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-阶段资料具体内容不能为空", false);
        Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getSummaryDataPic(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-资料图片概要地址不能为空", false);
        Assert.isNull(autoBuildEvaObjTarCycStaDataComReqDto.getTextSummaryData(), "B3一键构造单条被评对象目标周期标准数据验证数据-D3-一键构造被评对象目标周期标准数据验证数据(公共)-资料文字概要不能为空", false);
        autoBuildEvaObjTarCycStaDataComRespDto = fwAppSystemTestDomainClient.autoBuildEvaObjTarCycStaDataCom(autoBuildEvaObjTarCycStaDataComReqDto).getData();


        BffAutoBuildSingleEvaObjTarCycStaDataRespDto retData = new BffAutoBuildSingleEvaObjTarCycStaDataRespDto();


        return retData;
    }

    /**
     * B3一键构造单条虚拟组织成员验证数据(管理)[4529]
     * gen by moon at 9/12/2022, 10:16:36 PM
     */
    @Trace(operationName = "B3一键构造单条虚拟组织成员验证数据(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildSingleVirtualOrgMemRespDto autoBuildSingleVirtualOrgMem(BffAutoBuildSingleVirtualOrgMemReqDto reqDto) {


        //步骤0: D3一键构造单个虚拟组织成员验证数据 - autoBuildSingleVirtualOrgMember
        AutoBuildSingleVirtualOrgMemberRespDto autoBuildSingleVirtualOrgMemberRespDto = null;
        AutoBuildSingleVirtualOrgMemberReqDto autoBuildSingleVirtualOrgMemberReqDto = new AutoBuildSingleVirtualOrgMemberReqDto();
        if (reqDto != null) {
            autoBuildSingleVirtualOrgMemberReqDto.setVirtualOrgMemberId(reqDto.getVirtualOrgMemberId());//sourceId:319929_1
            autoBuildSingleVirtualOrgMemberReqDto.setVirtualOrgInductionRecordId(reqDto.getVirtualOrgInductionRecordId());//sourceId:319930_1
            autoBuildSingleVirtualOrgMemberReqDto.setRoleCode(reqDto.getRoleCode());//sourceId:319931_1
            autoBuildSingleVirtualOrgMemberReqDto.setVirtualOrganizationPosition(reqDto.getVirtualOrganizationPosition());//sourceId:319932_1
            autoBuildSingleVirtualOrgMemberReqDto.setIsAdmin(reqDto.getIsAdmin());//sourceId:319933_1
            autoBuildSingleVirtualOrgMemberReqDto.setIsDirectStakeholders(reqDto.getIsDirectStakeholders());//sourceId:319934_1
            autoBuildSingleVirtualOrgMemberReqDto.setIsUpperLowerLevels(reqDto.getIsUpperLowerLevels());//sourceId:319935_1
            autoBuildSingleVirtualOrgMemberReqDto.setIsPersonCharge(reqDto.getIsPersonCharge());//sourceId:319936_1
            autoBuildSingleVirtualOrgMemberReqDto.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:319937_1
            autoBuildSingleVirtualOrgMemberReqDto.setEntityId(reqDto.getEntityId());//sourceId:319938_1
            autoBuildSingleVirtualOrgMemberReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//sourceId:319939_1
        }

        /*D3一键构造单个虚拟组织成员验证数据[4527]   */

        autoBuildSingleVirtualOrgMemberRespDto = fwAppSystemTestDomainClient.autoBuildSingleVirtualOrgMember(autoBuildSingleVirtualOrgMemberReqDto).getData();


        BffAutoBuildSingleVirtualOrgMemRespDto retData = new BffAutoBuildSingleVirtualOrgMemRespDto();


        return retData;
    }

    /**
     * B4-1-01修改单条被评对象目标周期标准数据(管理)[4538]
     * gen by moon at 9/10/2022, 10:04:58 PM
     */
    @Trace(operationName = "B4-1-01修改单条被评对象目标周期标准数据(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateSingleEvaObjTarCycStaDataRespDto updateSingleEvaObjTarCycStaData(BffUpdateSingleEvaObjTarCycStaDataReqDto reqDto) {


        //步骤0: D4-1-01修改单条被评对象目标周期标准数据 - updateSingleEvaObjTarCycStaData
        UpdateSingleEvaObjTarCycStaDataRespDto updateSingleEvaObjTarCycStaDataRespDto = null;
        UpdateSingleEvaObjTarCycStaDataReqDto updateSingleEvaObjTarCycStaDataReqDto = new UpdateSingleEvaObjTarCycStaDataReqDto();
        if (reqDto != null) {
            updateSingleEvaObjTarCycStaDataReqDto.setPeriodId(reqDto.getPeriodId());//sourceId:320981_1
            updateSingleEvaObjTarCycStaDataReqDto.setEntityId(reqDto.getEntityId());//sourceId:320983_1
            updateSingleEvaObjTarCycStaDataReqDto.setUnit(reqDto.getUnit());//sourceId:320985_1
            updateSingleEvaObjTarCycStaDataReqDto.setIsNewData(reqDto.getIsNewData());//sourceId:320986_1
            updateSingleEvaObjTarCycStaDataReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:320987_1
            updateSingleEvaObjTarCycStaDataReqDto.setIsArchive(reqDto.getIsArchive());//sourceId:320988_1
            updateSingleEvaObjTarCycStaDataReqDto.setActualValue(reqDto.getActualValue());//sourceId:320982_1
            updateSingleEvaObjTarCycStaDataReqDto.setParentActualValue(reqDto.getParentActualValue());//sourceId:320984_1
            updateSingleEvaObjTarCycStaDataReqDto.setProgressValue(reqDto.getProgressValue());//sourceId:320989_1
            updateSingleEvaObjTarCycStaDataReqDto.setParentProgressValue(reqDto.getParentProgressValue());//sourceId:320990_1
            updateSingleEvaObjTarCycStaDataReqDto.setReach(reqDto.getReach());//sourceId:320991_1
            updateSingleEvaObjTarCycStaDataReqDto.setParentReach(reqDto.getParentReach());//sourceId:320992_1
            updateSingleEvaObjTarCycStaDataReqDto.setRealTimeScore(reqDto.getRealTimeScore());//sourceId:320993_1
            updateSingleEvaObjTarCycStaDataReqDto.setParentRealTimeScore(reqDto.getParentRealTimeScore());//sourceId:320994_1
            updateSingleEvaObjTarCycStaDataReqDto.setProgressFromLastRatio(reqDto.getProgressFromLastRatio());//sourceId:320995_1
            updateSingleEvaObjTarCycStaDataReqDto.setParentProgressFromLastRatio(reqDto.getParentProgressFromLastRatio());//sourceId:320996_1
            updateSingleEvaObjTarCycStaDataReqDto.setActualFromLastTimeRatio(reqDto.getActualFromLastTimeRatio());//sourceId:320997_1
            updateSingleEvaObjTarCycStaDataReqDto.setParentActualFromLastTimeRatio(reqDto.getParentActualFromLastTimeRatio());//sourceId:320998_1
        }

        /*D4-1-01修改单条被评对象目标周期标准数据[4535]   */
        Assert.isNull(updateSingleEvaObjTarCycStaDataReqDto.getPeriodId(), "B4-1-01修改单条被评对象目标周期标准数据(管理)-D4-1-01修改单条被评对象目标周期标准数据-周期ID不能为空", false);
        Assert.isNull(updateSingleEvaObjTarCycStaDataReqDto.getEntityId(), "B4-1-01修改单条被评对象目标周期标准数据(管理)-D4-1-01修改单条被评对象目标周期标准数据-被评对象目标周期ID不能为空", false);
        updateSingleEvaObjTarCycStaDataRespDto = fwCalcSystemTestDomainClient.updateSingleEvaObjTarCycStaData(updateSingleEvaObjTarCycStaDataReqDto).getData();


        BffUpdateSingleEvaObjTarCycStaDataRespDto retData = new BffUpdateSingleEvaObjTarCycStaDataRespDto();


        return retData;
    }

    /**
     * B3一键构造父子状态测试验证数据[4487]
     * gen by moon at 9/12/2022, 10:16:22 PM
     */
    @Trace(operationName = "B3一键构造父子状态测试验证数据")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildAssistNnodeStatusTestRespDto autoBuildAssistNnodeStatusTest(BffAutoBuildAssistNnodeStatusTestReqDto reqDto) {


        //步骤0: D3-构造父子状态测试验证数据 - buildAssistNnodeStatusTest
        BuildAssistNnodeStatusTestRespDto buildAssistNnodeStatusTestRespDto = null;
        BuildAssistNnodeStatusTestReqDto buildAssistNnodeStatusTestReqDto = new BuildAssistNnodeStatusTestReqDto();
        if (reqDto != null) {
            buildAssistNnodeStatusTestReqDto.setAssistNodeTypeCode(reqDto.getAssistNodeTypeCode());//sourceId:313763_1
            buildAssistNnodeStatusTestReqDto.setAssistNodeTypeObjectId(reqDto.getAssistNodeTypeObjectId());//sourceId:313764_1
            buildAssistNnodeStatusTestReqDto.setAssistNodeTypeObjectCode(reqDto.getAssistNodeTypeObjectCode());//sourceId:313765_1
            buildAssistNnodeStatusTestReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:313766_1
            buildAssistNnodeStatusTestReqDto.setObjectId(reqDto.getObjectId());//sourceId:313767_1
            buildAssistNnodeStatusTestReqDto.setUpdateAssistNodeStatusId(reqDto.getUpdateAssistNodeStatusId());//sourceId:313768_1
            buildAssistNnodeStatusTestReqDto.setNextNodeNum(reqDto.getNextNodeNum());//sourceId:313769_1
            buildAssistNnodeStatusTestReqDto.setNextNodeDoneNum(reqDto.getNextNodeDoneNum());//sourceId:313770_1
            buildAssistNnodeStatusTestReqDto.setDisplayStatus(reqDto.getDisplayStatus());//sourceId:313771_1
            buildAssistNnodeStatusTestReqDto.setIsComplete(reqDto.getIsComplete());//sourceId:313772_1
            buildAssistNnodeStatusTestReqDto.setCurrentLevelComplete(reqDto.getCurrentLevelComplete());//sourceId:313773_1
            buildAssistNnodeStatusTestReqDto.setNextLevelComplete(reqDto.getNextLevelComplete());//sourceId:313774_1
            buildAssistNnodeStatusTestReqDto.setCreateInductionId(reqDto.getCreateInductionId());//sourceId:313775_1
            buildAssistNnodeStatusTestReqDto.setSpaceId(reqDto.getSpaceId());//sourceId:313776_1
            buildAssistNnodeStatusTestReqDto.setAppId(reqDto.getAppId());//sourceId:313777_1
        }

        /*D3-构造父子状态测试验证数据[4486]   */
        Assert.isNull(buildAssistNnodeStatusTestReqDto.getCreateInductionId(), "B3一键构造父子状态测试验证数据-D3-构造父子状态测试验证数据-创建人就职记录ID 不能为空", false);
        Assert.isNull(buildAssistNnodeStatusTestReqDto.getSpaceId(), "B3一键构造父子状态测试验证数据-D3-构造父子状态测试验证数据-创建于空间ID不能为空", false);
        Assert.isNull(buildAssistNnodeStatusTestReqDto.getAppId(), "B3一键构造父子状态测试验证数据-D3-构造父子状态测试验证数据-创建于联盟应用ID不能为空", false);
        buildAssistNnodeStatusTestRespDto = fwAppSystemTestDomainClient.buildAssistNnodeStatusTest(buildAssistNnodeStatusTestReqDto).getData();


        BffAutoBuildAssistNnodeStatusTestRespDto retData = new BffAutoBuildAssistNnodeStatusTestRespDto();


        return retData;
    }

    /**
     * B3一键构造单条批次验证数据(管理)[4497]
     * gen by moon at 9/12/2022, 10:16:30 PM
     */
    @Trace(operationName = "B3一键构造单条批次验证数据(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffAutoBuildSingleBatchRespDto autoBuildSingleBatch(BffAutoBuildSingleBatchReqDto reqDto) {


        BuildSingleBatchComRespDto buildSingleBatchComRespDto_1 = null;
//步骤0: D3-13构造单条批次验证数据(公共) - buildSingleBatchCom
        BuildSingleBatchComRespDto buildSingleBatchComRespDto = null;
        BuildSingleBatchComReqDto buildSingleBatchComReqDto = new BuildSingleBatchComReqDto();
        if (reqDto != null) {
            buildSingleBatchComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:315216_1
            buildSingleBatchComReqDto.setIsFirst(reqDto.getIsFirst());//sourceId:315218_1
            buildSingleBatchComReqDto.setBatchName(reqDto.getBatchName());//sourceId:315217_1
            buildSingleBatchComReqDto.setPurposeTypeCode(reqDto.getPurposeTypeCode());//sourceId:315219_1
            buildSingleBatchComReqDto.setAscriptionObjectId(reqDto.getAscriptionObjectId());//sourceId:315220_1
            buildSingleBatchComReqDto.setBatchSetObjectType(reqDto.getBatchSetObjectType());//sourceId:315221_1
            buildSingleBatchComReqDto.setCurrentManageObjectType(reqDto.getCurrentManageObjectType());//sourceId:315222_1
            buildSingleBatchComReqDto.setHistoricalArchiveBatchName(reqDto.getHistoricalArchiveBatchName());//sourceId:315228_1
            buildSingleBatchComReqDto.setArchivngType(reqDto.getArchivngType());//sourceId:315224_1
        }

        /*D3-13构造单条批次验证数据(公共)[4251]   */
        Assert.isNull(buildSingleBatchComReqDto.getPurposeTypeCode(), "B3一键构造单条批次验证数据(管理)-D3-13构造单条批次验证数据(公共)-用途类型编码不能为空", false);
        Assert.isNull(buildSingleBatchComReqDto.getAscriptionObjectId(), "B3一键构造单条批次验证数据(管理)-D3-13构造单条批次验证数据(公共)-归属对象ID不能为空", false);
        Assert.isNull(buildSingleBatchComReqDto.getBatchSetObjectType(), "B3一键构造单条批次验证数据(管理)-D3-13构造单条批次验证数据(公共)-批次设置对象类型不能为空", false);
        Assert.isNull(buildSingleBatchComReqDto.getCurrentManageObjectType(), "B3一键构造单条批次验证数据(管理)-D3-13构造单条批次验证数据(公共)-当前管理对象类型不能为空", false);
        buildSingleBatchComRespDto = fwAppSystemTestDomainClient.buildSingleBatchCom(buildSingleBatchComReqDto).getData();


        buildSingleBatchComRespDto_1 = buildSingleBatchComRespDto;

        BffAutoBuildSingleBatchRespDto retData = new BffAutoBuildSingleBatchRespDto();
        if (buildSingleBatchComRespDto_1 != null) {
            retData.setBatchCode(buildSingleBatchComRespDto_1.getBatchCode());//sourceId:322774_1
            retData.setPreviousBatchCode(buildSingleBatchComRespDto_1.getPreviousBatchCode());//sourceId:322775_1
            retData.setBatchRelatedSetId(buildSingleBatchComRespDto_1.getBatchRelatedSetId());//sourceId:322776_1
        }


        return retData;
    }

    /**
     * B3-3修改评价模板规划类型标准数据[4554]
     * gen by moon at 9/14/2022, 12:27:17 AM
     */
    @Trace(operationName = "B3-3修改评价模板规划类型标准数据")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffUpdateEvaTempTypeEtcRespDto updateEvaTempTypeEtc(BffUpdateEvaTempTypeEtcReqDto reqDto) {


        //步骤0: D3-3修改评价模板规划类型标准数据 - updateEvaTempTypeEtc
        UpdateEvaTempTypeEtcRespDto updateEvaTempTypeEtcRespDto = null;
        UpdateEvaTempTypeEtcReqDto updateEvaTempTypeEtcReqDto = new UpdateEvaTempTypeEtcReqDto();
        if (reqDto != null) {
            updateEvaTempTypeEtcReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//sourceId:324309_1
            updateEvaTempTypeEtcReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//sourceId:324311_1
            updateEvaTempTypeEtcReqDto.setEvaluationTemplateTypeCode(reqDto.getEvaluationTemplateTypeCode());//sourceId:324312_1
            updateEvaTempTypeEtcReqDto.setTargetPlanTempSubtype(reqDto.getTargetPlanTempSubtype());//sourceId:324313_1
            updateEvaTempTypeEtcReqDto.setEvaluationSubjectTypeCode(reqDto.getEvaluationSubjectTypeCode());//sourceId:324314_1
            updateEvaTempTypeEtcReqDto.setPlanningType(reqDto.getPlanningType());//sourceId:324315_1
            updateEvaTempTypeEtcReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//sourceId:324310_1
        }

        /*D3-3修改评价模板规划类型标准数据[4555]   */
        Assert.isNull(updateEvaTempTypeEtcReqDto.getEvaluationTemplateId(), "B3-3修改评价模板规划类型标准数据-D3-3修改评价模板规划类型标准数据-评价模板ID不能为空", false);
        updateEvaTempTypeEtcRespDto = fwAppSystemTestDomainClient.updateEvaTempTypeEtc(updateEvaTempTypeEtcReqDto).getData();


        BffUpdateEvaTempTypeEtcRespDto retData = new BffUpdateEvaTempTypeEtcRespDto();


        return retData;
    }

    /**
     * B3执行被评对象目标周期测试数据[4565]
     * gen by moon at 9/15/2022, 9:51:25 PM
     */
    @Trace(operationName = "B3执行被评对象目标周期测试数据")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementEvaObjTarCycTestDataRespDto implementEvaObjTarCycTestData(BffImplementEvaObjTarCycTestDataReqDto reqDto) {


        BffImplementEvaObjTarCycTestDataRespDto retData = new BffImplementEvaObjTarCycTestDataRespDto();


        return retData;
    }

    /**
     * 【超危险】B1删除空间测试(管理)【超危险】[4871]
     * gen by moon at 10/16/2022, 11:33:16 AM
     */
    @Trace(operationName = "【超危险】B1删除空间测试(管理)【超危险】")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffDeleteSpaceTestDataRespDto deleteSpaceTestData(BffDeleteSpaceTestDataReqDto reqDto) {


        //步骤0: D1删除空间测试 - deleteSpaceTestData
        DeleteSpaceTestDataRespDto deleteSpaceTestDataRespDto = null;
        DeleteSpaceTestDataReqDto deleteSpaceTestDataReqDto = new DeleteSpaceTestDataReqDto();
        if (reqDto != null) {
            deleteSpaceTestDataReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:380733_1
        }

        /*D1删除空间测试[4872]   */
        Assert.isNull(deleteSpaceTestDataReqDto.getSpaceId(), "【超危险】B1删除空间测试(管理)【超危险】-D1删除空间测试-空间ID不能为空", false);
        deleteSpaceTestDataRespDto = fwBaseSystemTestDomainClient.deleteSpaceTestData(deleteSpaceTestDataReqDto).getData();


        BffDeleteSpaceTestDataRespDto retData = new BffDeleteSpaceTestDataRespDto();


        return retData;
    }

    /**
     * B3批量删部门目标任务树测试(管理)[5126]
     * gen by moon at 11/9/2022, 11:51:41 PM
     */
    @Trace(operationName = "B3批量删部门目标任务树测试(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffBatchDeleteDeptObjTreeTestDataRespDto batchDeleteDeptObjTreeTestData(BffBatchDeleteDeptObjTreeTestDataReqDto reqDto) {


        //步骤0: D3删除部门目标任务树测试(公共) - deleteDeptObjTreeTestDataCom
        DeleteDeptObjTreeTestDataComRespDto deleteDeptObjTreeTestDataComRespDto = null;
        DeleteDeptObjTreeTestDataComReqDto deleteDeptObjTreeTestDataComReqDto = new DeleteDeptObjTreeTestDataComReqDto();
        if (reqDto != null) {
            deleteDeptObjTreeTestDataComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:419934_1
            deleteDeptObjTreeTestDataComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:419935_1
            deleteDeptObjTreeTestDataComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:419936_1
            deleteDeptObjTreeTestDataComReqDto.setTreeTypeCode(reqDto.getTreeTypeCode());//SimpleFieldAssign//sourceId:419937_1
            deleteDeptObjTreeTestDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:427535_1
        }

        /*D3删除部门目标任务树测试(公共)[5123]   */
        Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getEvaObjEntityId(), "B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getEvaObjTableTypeCode(), "B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-被评对象内容表类型编码不能为空", false);
        Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getEvaObjTypeCode(), "B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getTreeTypeCode(), "B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-树类型编码不能为空", false);
        Assert.isNull(deleteDeptObjTreeTestDataComReqDto.getEvaluationTemplateId(), "B3批量删部门目标任务树测试(管理)-D3删除部门目标任务树测试(公共)-冗余评价模板ID不能为空", false);
        deleteDeptObjTreeTestDataComRespDto = fwAppSystemTestDomainClient.deleteDeptObjTreeTestDataCom(deleteDeptObjTreeTestDataComReqDto).getData();


        BffBatchDeleteDeptObjTreeTestDataRespDto retData = new BffBatchDeleteDeptObjTreeTestDataRespDto();


        return retData;
    }

    /**
     * B3批量删部门下目标内容测试(管理)(公共)[5130]
     * gen by moon at 11/4/2022, 7:39:36 AM
     */
    @Trace(operationName = "B3批量删部门下目标内容测试(管理)(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffBatchDeleteDeptTargetContentTestComRespDto batchDeleteDeptTargetContentTestCom(BffBatchDeleteDeptTargetContentTestComReqDto reqDto) {


        //步骤0: D3批量删部门下目标内容测试(公共) - batchDeleteDeptTargetContentTestCom
        BatchDeleteDeptTargetContentTestComRespDto batchDeleteDeptTargetContentTestComRespDto = null;
        BatchDeleteDeptTargetContentTestComReqDto batchDeleteDeptTargetContentTestComReqDto = new BatchDeleteDeptTargetContentTestComReqDto();
        if (reqDto != null) {
            batchDeleteDeptTargetContentTestComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:419990_1
            batchDeleteDeptTargetContentTestComReqDto.setEvaluationTemplateType(reqDto.getEvaluationTemplateType());//SimpleFieldAssign//sourceId:419991_1
            batchDeleteDeptTargetContentTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:419992_1
        }

        /*D3批量删部门下目标内容测试(公共)[5127]   */
        Assert.isNull(batchDeleteDeptTargetContentTestComReqDto.getDeptId(), "B3批量删部门下目标内容测试(管理)(公共)-D3批量删部门下目标内容测试(公共)-虚拟组织下部门ID不能为空", false);
        batchDeleteDeptTargetContentTestComRespDto = fwAppSystemTestDomainClient.batchDeleteDeptTargetContentTestCom(batchDeleteDeptTargetContentTestComReqDto).getData();


        BffBatchDeleteDeptTargetContentTestComRespDto retData = new BffBatchDeleteDeptTargetContentTestComRespDto();


        return retData;
    }

    /**
     * B3-执行更新状态检查项数据测试(管理）[5534]
     * gen by moon at 12/27/2022, 9:01:17 PM
     */
    @Trace(operationName = "B3-执行更新状态检查项数据测试(管理）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementUpdateStatusCheckItemDataRespDto implementUpdateStatusCheckItemData(BffImplementUpdateStatusCheckItemDataReqDto reqDto) {


        //步骤0: D3-执行更新状态检查项数据测试 - implementUpdateStatusCheckItemData
        ImplementUpdateStatusCheckItemDataRespDto implementUpdateStatusCheckItemDataRespDto = null;
        ImplementUpdateStatusCheckItemDataReqDto implementUpdateStatusCheckItemDataReqDto = new ImplementUpdateStatusCheckItemDataReqDto();
        if (reqDto != null) {
            implementUpdateStatusCheckItemDataReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:550404_1
        }

        /*D3-执行更新状态检查项数据测试[5535]   */
        Assert.isNull(implementUpdateStatusCheckItemDataReqDto.getSpaceId(), "B3-执行更新状态检查项数据测试(管理）-D3-执行更新状态检查项数据测试-创建于空间ID不能为空", false);
        implementUpdateStatusCheckItemDataRespDto = fwAppSystemTestDomainClient.implementUpdateStatusCheckItemData(implementUpdateStatusCheckItemDataReqDto).getData();


        BffImplementUpdateStatusCheckItemDataRespDto retData = new BffImplementUpdateStatusCheckItemDataRespDto();


        return retData;
    }

    /**
     * B3-批量更新模板下父子状态检查项等测试(平台）[5564]
     * gen by moon at 12/30/2022, 6:41:07 PM
     */
    @Trace(operationName = "B3-批量更新模板下父子状态检查项等测试(平台）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffBatchRefreshAssistNnodeStatusEtcTestRespDto batchRefreshAssistNnodeStatusEtcTest(BffBatchRefreshAssistNnodeStatusEtcTestReqDto reqDto) {


        //步骤0: D3-执行更新状态检查项数据测试(公共) - implementUpdateStatusCheckItemDataCom
        ImplementUpdateStatusCheckItemDataComRespDto implementUpdateStatusCheckItemDataComRespDto = null;
        ImplementUpdateStatusCheckItemDataComReqDto implementUpdateStatusCheckItemDataComReqDto = new ImplementUpdateStatusCheckItemDataComReqDto();
        if (reqDto != null) {
            implementUpdateStatusCheckItemDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:556847_1
        }

        /*D3-执行更新状态检查项数据测试(公共)[5560]   */
        Assert.isNull(implementUpdateStatusCheckItemDataComReqDto.getEvaluationTemplateId(), "B3-批量更新模板下父子状态检查项等测试(平台）-D3-执行更新状态检查项数据测试(公共)-冗余评价模板ID不能为空", false);
        implementUpdateStatusCheckItemDataComRespDto = fwAppSystemTestDomainClient.implementUpdateStatusCheckItemDataCom(implementUpdateStatusCheckItemDataComReqDto).getData();


//步骤1: D3-执行更新仪表盘数据测试(公共) - implementUpdateAssistCheckPanelTestCom
        ImplementUpdateAssistCheckPanelTestComRespDto implementUpdateAssistCheckPanelTestComRespDto = null;
        ImplementUpdateAssistCheckPanelTestComReqDto implementUpdateAssistCheckPanelTestComReqDto = new ImplementUpdateAssistCheckPanelTestComReqDto();
        if (reqDto != null) {
            implementUpdateAssistCheckPanelTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:556846_1
        }

        /*D3-执行更新仪表盘数据测试(公共)[5553]   */
        Assert.isNull(implementUpdateAssistCheckPanelTestComReqDto.getEvaluationTemplateId(), "B3-批量更新模板下父子状态检查项等测试(平台）-D3-执行更新仪表盘数据测试(公共)-冗余评价模板ID不能为空", false);
        implementUpdateAssistCheckPanelTestComRespDto = fwAppSystemTestDomainClient.implementUpdateAssistCheckPanelTestCom(implementUpdateAssistCheckPanelTestComReqDto).getData();


//步骤2: D3-执行更新父子状态数据测试(公共) - implementUpdateAssistNnodeStatusTestCom
        ImplementUpdateAssistNnodeStatusTestComRespDto implementUpdateAssistNnodeStatusTestComRespDto = null;
        ImplementUpdateAssistNnodeStatusTestComReqDto implementUpdateAssistNnodeStatusTestComReqDto = new ImplementUpdateAssistNnodeStatusTestComReqDto();
        if (reqDto != null) {
            implementUpdateAssistNnodeStatusTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:556845_1
        }

        /*D3-执行更新父子状态数据测试(公共)[5556]   */
        Assert.isNull(implementUpdateAssistNnodeStatusTestComReqDto.getEvaluationTemplateId(), "B3-批量更新模板下父子状态检查项等测试(平台）-D3-执行更新父子状态数据测试(公共)-冗余评价模板ID不能为空", false);
        implementUpdateAssistNnodeStatusTestComRespDto = fwAppSystemTestDomainClient.implementUpdateAssistNnodeStatusTestCom(implementUpdateAssistNnodeStatusTestComReqDto).getData();


        BffBatchRefreshAssistNnodeStatusEtcTestRespDto retData = new BffBatchRefreshAssistNnodeStatusEtcTestRespDto();


        return retData;
    }

    /**
     * B3执行修正模板下内容上级父子状态数据测试(平台）[5956]
     * gen by moon at 2/19/2023, 4:50:53 PM
     */
    @Trace(operationName = "B3执行修正模板下内容上级父子状态数据测试(平台）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementCorrectionTempParentNodeStatusTestRespDto implementCorrectionTempParentNodeStatusTest(BffImplementCorrectionTempParentNodeStatusTestReqDto reqDto) {


        //步骤0: D3执行修正模板下内容上级父子状态数据测试 - implementCorrectionTempParentNodeStatusTest
        ImplementCorrectionTempParentNodeStatusTestRespDto implementCorrectionTempParentNodeStatusTestRespDto = null;
        ImplementCorrectionTempParentNodeStatusTestReqDto implementCorrectionTempParentNodeStatusTestReqDto = new ImplementCorrectionTempParentNodeStatusTestReqDto();
        if (reqDto != null) {
            implementCorrectionTempParentNodeStatusTestReqDto.setComCode(reqDto.getComCode());//SimpleFieldAssign//sourceId:690029_1
            implementCorrectionTempParentNodeStatusTestReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:690027_1
            implementCorrectionTempParentNodeStatusTestReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:690028_1
        }

        /*D3执行修正模板下内容上级父子状态数据测试[5953]   */
        Assert.isNull(implementCorrectionTempParentNodeStatusTestReqDto.getComCode(), "B3执行修正模板下内容上级父子状态数据测试(平台）-D3执行修正模板下内容上级父子状态数据测试-通用编码标识不能为空", false);
        Assert.isNull(implementCorrectionTempParentNodeStatusTestReqDto.getEvaluationTemplateId(), "B3执行修正模板下内容上级父子状态数据测试(平台）-D3执行修正模板下内容上级父子状态数据测试-冗余评价模板ID不能为空", false);
        Assert.isNull(implementCorrectionTempParentNodeStatusTestReqDto.getSpaceId(), "B3执行修正模板下内容上级父子状态数据测试(平台）-D3执行修正模板下内容上级父子状态数据测试-创建于空间ID不能为空", false);
        implementCorrectionTempParentNodeStatusTestRespDto = fwAppSystemTestDomainClient.implementCorrectionTempParentNodeStatusTest(implementCorrectionTempParentNodeStatusTestReqDto).getData();


        BffImplementCorrectionTempParentNodeStatusTestRespDto retData = new BffImplementCorrectionTempParentNodeStatusTestRespDto();


        return retData;
    }

    /**
     * B3执行目标内容检查项状态等三大件刷新测试(平台）[6133]
     * gen by moon at 4/5/2023, 5:50:16 PM
     */
    @Trace(operationName = "B3执行目标内容检查项状态等三大件刷新测试(平台）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementTargetContCheckItemThreeTestRespDto implementTargetContCheckItemThreeTest(BffImplementTargetContCheckItemThreeTestReqDto reqDto) {


        //步骤0: D3执行目标内容检查项状态等三大件刷新测试(公共) - implementTargetContCheckItemThreeTestCom
        ImplementTargetContCheckItemThreeTestComRespDto implementTargetContCheckItemThreeTestComRespDto = null;
        ImplementTargetContCheckItemThreeTestComReqDto implementTargetContCheckItemThreeTestComReqDto = new ImplementTargetContCheckItemThreeTestComReqDto();
        if (reqDto != null) {
            implementTargetContCheckItemThreeTestComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:773152_1
            implementTargetContCheckItemThreeTestComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:773153_1
            implementTargetContCheckItemThreeTestComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:811631_1
//implementTargetContCheckItemThreeTestComReqDto.setUpdateEvaObjTypeCode(reqDto.getUpdateEvaObjTypeCode());//SimpleFieldAssign//sourceId:811632_1
            implementTargetContCheckItemThreeTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:773151_1
            implementTargetContCheckItemThreeTestComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:773155_1
            implementTargetContCheckItemThreeTestComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:773156_1
            implementTargetContCheckItemThreeTestComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:773157_1
        }

        /*D3执行目标内容检查项状态等三大件刷新测试(公共)[6130]   */
        Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getEvaObjTargetCycleCode(), "B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-被评对象目标周期标识不能为空", false);
        Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getEvaObjEntityId(), "B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getEvaObjTypeCode(), "B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getEvaluationTemplateId(), "B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getCreateInductionId(), "B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getSpaceId(), "B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-创建于空间ID不能为空", false);
        Assert.isNull(implementTargetContCheckItemThreeTestComReqDto.getAppId(), "B3执行目标内容检查项状态等三大件刷新测试(平台）-D3执行目标内容检查项状态等三大件刷新测试(公共)-创建于联盟应用ID不能为空", false);
        implementTargetContCheckItemThreeTestComRespDto = fwAppSystemTestDomainClient.implementTargetContCheckItemThreeTestCom(implementTargetContCheckItemThreeTestComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementTargetContCheckItemThreeTestRespDto retData = new BffImplementTargetContCheckItemThreeTestRespDto();


        return retData;
    }

    /**
     * B3执行清理目标内容垃圾数据测试[6231]
     * gen by moon at 4/7/2023, 3:03:56 PM
     */
    @Trace(operationName = "B3执行清理目标内容垃圾数据测试")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementCleanTargetContRubbishDataRespDto implementCleanTargetContRubbishData(BffImplementCleanTargetContRubbishDataReqDto reqDto) {


        //步骤0: D3执行清理目标内容垃圾数据测试(公共) - implementCleanTargetContRubbishDataCom
        ImplementCleanTargetContRubbishDataComRespDto implementCleanTargetContRubbishDataComRespDto = null;
        ImplementCleanTargetContRubbishDataComReqDto implementCleanTargetContRubbishDataComReqDto = new ImplementCleanTargetContRubbishDataComReqDto();
        if (reqDto != null) {
            implementCleanTargetContRubbishDataComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:813655_1
            implementCleanTargetContRubbishDataComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:813656_1
            implementCleanTargetContRubbishDataComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:813657_1
            implementCleanTargetContRubbishDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:813658_1
            implementCleanTargetContRubbishDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813659_1
            implementCleanTargetContRubbishDataComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813660_1
            implementCleanTargetContRubbishDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813661_1
            implementCleanTargetContRubbishDataComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813662_1
        }

        /*D3执行清理目标内容垃圾数据测试(公共)[6219]   */
        Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getEvaObjTargetCycleCode(), "B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-被评对象目标周期标识不能为空", false);
        Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getEvaObjEntityId(), "B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getEvaObjTypeCode(), "B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getTargetCycleContentId(), "B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getEvaluationTemplateId(), "B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getCreateInductionId(), "B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getSpaceId(), "B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-创建于空间ID不能为空", false);
        Assert.isNull(implementCleanTargetContRubbishDataComReqDto.getAppId(), "B3执行清理目标内容垃圾数据测试-D3执行清理目标内容垃圾数据测试(公共)-创建于联盟应用ID不能为空", false);
        implementCleanTargetContRubbishDataComRespDto = fwAppSystemTestDomainClient.implementCleanTargetContRubbishDataCom(implementCleanTargetContRubbishDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementCleanTargetContRubbishDataRespDto retData = new BffImplementCleanTargetContRubbishDataRespDto();


        return retData;
    }

    /**
     * B3执行指标负责人情况分析测试[6232]
     * gen by moon at 4/7/2023, 3:04:04 PM
     */
    @Trace(operationName = "B3执行指标负责人情况分析测试")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementObjtivePrincipalAnalyseRespDto implementObjtivePrincipalAnalyse(BffImplementObjtivePrincipalAnalyseReqDto reqDto) {


        //步骤0: D3执行指标负责人情况分析测试(公共) - implementObjtivePrincipalAnalyseCom
        ImplementObjtivePrincipalAnalyseComRespDto implementObjtivePrincipalAnalyseComRespDto = null;
        ImplementObjtivePrincipalAnalyseComReqDto implementObjtivePrincipalAnalyseComReqDto = new ImplementObjtivePrincipalAnalyseComReqDto();
        if (reqDto != null) {
            implementObjtivePrincipalAnalyseComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813674_1
            implementObjtivePrincipalAnalyseComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813671_1
            implementObjtivePrincipalAnalyseComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813672_1
            implementObjtivePrincipalAnalyseComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813673_1
        }

        /*D3执行指标负责人情况分析测试(公共)[6224]   */
        Assert.isNull(implementObjtivePrincipalAnalyseComReqDto.getEvaluationTemplateId(), "B3执行指标负责人情况分析测试-D3执行指标负责人情况分析测试(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(implementObjtivePrincipalAnalyseComReqDto.getCreateInductionId(), "B3执行指标负责人情况分析测试-D3执行指标负责人情况分析测试(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(implementObjtivePrincipalAnalyseComReqDto.getSpaceId(), "B3执行指标负责人情况分析测试-D3执行指标负责人情况分析测试(公共)-创建于空间ID不能为空", false);
        Assert.isNull(implementObjtivePrincipalAnalyseComReqDto.getAppId(), "B3执行指标负责人情况分析测试-D3执行指标负责人情况分析测试(公共)-创建于联盟应用ID不能为空", false);
        implementObjtivePrincipalAnalyseComRespDto = fwAppSystemTestDomainClient.implementObjtivePrincipalAnalyseCom(implementObjtivePrincipalAnalyseComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementObjtivePrincipalAnalyseRespDto retData = new BffImplementObjtivePrincipalAnalyseRespDto();


        return retData;
    }

    /**
     * B3执行循环初始化部门OKR根节点检查项状态测试[6233]
     * gen by moon at 4/7/2023, 3:04:13 PM
     */
    @Trace(operationName = "B3执行循环初始化部门OKR根节点检查项状态测试")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementLoopInitializeDeptOkrRootNodeCheckitemStateRespDto implementLoopInitializeDeptOkrRootNodeCheckitemState(BffImplementLoopInitializeDeptOkrRootNodeCheckitemStateReqDto reqDto) {


        //步骤0: D3执行循环初始化部门OKR根节点检查项状态测试(公共) - implementLoopInitializeDeptOkrRootNodeCheckitemStateCom
        ImplementLoopInitializeDeptOkrRootNodeCheckitemStateComRespDto implementLoopInitializeDeptOkrRootNodeCheckitemStateComRespDto = null;
        ImplementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto = new ImplementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto();
        if (reqDto != null) {
            implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813680_1
            implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813681_1
            implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813682_1
            implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813683_1
        }

        /*D3执行循环初始化部门OKR根节点检查项状态测试(公共)[6227]   */
        Assert.isNull(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.getEvaluationTemplateId(), "B3执行循环初始化部门OKR根节点检查项状态测试-D3执行循环初始化部门OKR根节点检查项状态测试(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.getCreateInductionId(), "B3执行循环初始化部门OKR根节点检查项状态测试-D3执行循环初始化部门OKR根节点检查项状态测试(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.getSpaceId(), "B3执行循环初始化部门OKR根节点检查项状态测试-D3执行循环初始化部门OKR根节点检查项状态测试(公共)-创建于空间ID不能为空", false);
        Assert.isNull(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto.getAppId(), "B3执行循环初始化部门OKR根节点检查项状态测试-D3执行循环初始化部门OKR根节点检查项状态测试(公共)-创建于联盟应用ID不能为空", false);
        implementLoopInitializeDeptOkrRootNodeCheckitemStateComRespDto = fwAppSystemTestDomainClient.implementLoopInitializeDeptOkrRootNodeCheckitemStateCom(implementLoopInitializeDeptOkrRootNodeCheckitemStateComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementLoopInitializeDeptOkrRootNodeCheckitemStateRespDto retData = new BffImplementLoopInitializeDeptOkrRootNodeCheckitemStateRespDto();


        return retData;
    }

    /**
     * B3执行补偿指标其他三棵树节点[6234]
     * gen by moon at 4/7/2023, 3:04:21 PM
     */
    @Trace(operationName = "B3执行补偿指标其他三棵树节点")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementCompensateObjtiveOtherTreeNodeRespDto implementCompensateObjtiveOtherTreeNode(BffImplementCompensateObjtiveOtherTreeNodeReqDto reqDto) {


        //步骤0: D3执行补偿指标其他三棵树节点测试(公共) - implementCompensateObjtiveOtherTreeNodeCom
        ImplementCompensateObjtiveOtherTreeNodeComRespDto implementCompensateObjtiveOtherTreeNodeComRespDto = null;
        ImplementCompensateObjtiveOtherTreeNodeComReqDto implementCompensateObjtiveOtherTreeNodeComReqDto = new ImplementCompensateObjtiveOtherTreeNodeComReqDto();
        if (reqDto != null) {
            implementCompensateObjtiveOtherTreeNodeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813688_1
            implementCompensateObjtiveOtherTreeNodeComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813689_1
            implementCompensateObjtiveOtherTreeNodeComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813690_1
            implementCompensateObjtiveOtherTreeNodeComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813691_1
        }

        /*D3执行补偿指标其他三棵树节点测试(公共)[6220]   */
        Assert.isNull(implementCompensateObjtiveOtherTreeNodeComReqDto.getEvaluationTemplateId(), "B3执行补偿指标其他三棵树节点-D3执行补偿指标其他三棵树节点测试(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(implementCompensateObjtiveOtherTreeNodeComReqDto.getCreateInductionId(), "B3执行补偿指标其他三棵树节点-D3执行补偿指标其他三棵树节点测试(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(implementCompensateObjtiveOtherTreeNodeComReqDto.getSpaceId(), "B3执行补偿指标其他三棵树节点-D3执行补偿指标其他三棵树节点测试(公共)-创建于空间ID不能为空", false);
        Assert.isNull(implementCompensateObjtiveOtherTreeNodeComReqDto.getAppId(), "B3执行补偿指标其他三棵树节点-D3执行补偿指标其他三棵树节点测试(公共)-创建于联盟应用ID不能为空", false);
        implementCompensateObjtiveOtherTreeNodeComRespDto = fwAppSystemTestDomainClient.implementCompensateObjtiveOtherTreeNodeCom(implementCompensateObjtiveOtherTreeNodeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementCompensateObjtiveOtherTreeNodeRespDto retData = new BffImplementCompensateObjtiveOtherTreeNodeRespDto();


        return retData;
    }

    /**
     * B3执行部门目标任务书叶子父子状态刷新[6235]
     * gen by moon at 4/7/2023, 3:04:30 PM
     */
    @Trace(operationName = "B3执行部门目标任务书叶子父子状态刷新")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementDeptTargetTaskLeafNodeStateRespDto implementDeptTargetTaskLeafNodeState(BffImplementDeptTargetTaskLeafNodeStateReqDto reqDto) {


        //步骤0: D3执行部门目标任务书叶子父子状态刷新测试(公共) - implementDeptTargetTaskLeafNodeStateCom
        ImplementDeptTargetTaskLeafNodeStateComRespDto implementDeptTargetTaskLeafNodeStateComRespDto = null;
        ImplementDeptTargetTaskLeafNodeStateComReqDto implementDeptTargetTaskLeafNodeStateComReqDto = new ImplementDeptTargetTaskLeafNodeStateComReqDto();
        if (reqDto != null) {
            implementDeptTargetTaskLeafNodeStateComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:813700_1
            implementDeptTargetTaskLeafNodeStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813699_1
            implementDeptTargetTaskLeafNodeStateComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813696_1
            implementDeptTargetTaskLeafNodeStateComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813697_1
            implementDeptTargetTaskLeafNodeStateComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813698_1
        }

        /*D3执行部门目标任务书叶子父子状态刷新测试(公共)[6131]   */
        Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getEvaObjEntityId(), "B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getEvaluationTemplateId(), "B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getCreateInductionId(), "B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getSpaceId(), "B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-创建于空间ID不能为空", false);
        Assert.isNull(implementDeptTargetTaskLeafNodeStateComReqDto.getAppId(), "B3执行部门目标任务书叶子父子状态刷新-D3执行部门目标任务书叶子父子状态刷新测试(公共)-创建于联盟应用ID不能为空", false);
        implementDeptTargetTaskLeafNodeStateComRespDto = fwAppSystemTestDomainClient.implementDeptTargetTaskLeafNodeStateCom(implementDeptTargetTaskLeafNodeStateComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementDeptTargetTaskLeafNodeStateRespDto retData = new BffImplementDeptTargetTaskLeafNodeStateRespDto();


        return retData;
    }

    /**
     * B3执行OKR树检查项状态三大件初始化测试[6236]
     * gen by moon at 4/7/2023, 3:04:39 PM
     */
    @Trace(operationName = "B3执行OKR树检查项状态三大件初始化测试")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementOkrTreeCheckItemStateEtcInitializeEtcTestRespDto implementOkrTreeCheckItemStateEtcInitializeEtcTest(BffImplementOkrTreeCheckItemStateEtcInitializeEtcTestReqDto reqDto) {


        //步骤0: D3执行OKR树检查项状态三大件初始化测试(公共) - implementOkrTreeCheckItemStateEtcInitializeEtcTestCom
        ImplementOkrTreeCheckItemStateEtcInitializeEtcTestComRespDto implementOkrTreeCheckItemStateEtcInitializeEtcTestComRespDto = null;
        ImplementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto = new ImplementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto();
        if (reqDto != null) {
            implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:813709_1
            implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:813708_1
            implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:813707_1
            implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813706_1
        }

        /*D3执行OKR树检查项状态三大件初始化测试(公共)[6206]   */
        Assert.isNull(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.getEvaObjTargetCycleCode(), "B3执行OKR树检查项状态三大件初始化测试-D3执行OKR树检查项状态三大件初始化测试(公共)-被评对象目标周期标识不能为空", false);
        Assert.isNull(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.getEvaObjEntityId(), "B3执行OKR树检查项状态三大件初始化测试-D3执行OKR树检查项状态三大件初始化测试(公共)-被评对象内容表主键ID不能为空", false);
        Assert.isNull(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.getEvaObjTypeCode(), "B3执行OKR树检查项状态三大件初始化测试-D3执行OKR树检查项状态三大件初始化测试(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto.getEvaluationTemplateId(), "B3执行OKR树检查项状态三大件初始化测试-D3执行OKR树检查项状态三大件初始化测试(公共)-冗余评价模板ID不能为空", false);
        implementOkrTreeCheckItemStateEtcInitializeEtcTestComRespDto = fwAppSystemTestDomainClient.implementOkrTreeCheckItemStateEtcInitializeEtcTestCom(implementOkrTreeCheckItemStateEtcInitializeEtcTestComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementOkrTreeCheckItemStateEtcInitializeEtcTestRespDto retData = new BffImplementOkrTreeCheckItemStateEtcInitializeEtcTestRespDto();


        return retData;
    }

    /**
     * B3执行循环初始化OKR树检查项状态等测试（平台）[6239]
     * gen by moon at 4/7/2023, 3:04:47 PM
     */
    @Trace(operationName = "B3执行循环初始化OKR树检查项状态等测试（平台）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementLoopInitializeOkrTreeCheckitemStateEtcRespDto implementLoopInitializeOkrTreeCheckitemStateEtc(BffImplementLoopInitializeOkrTreeCheckitemStateEtcReqDto reqDto) {


        //步骤0: D3执行循环初始化OKR树检查项状态等测试(公共) - implementLoopInitializeOkrTreeCheckitemStateEtcCom
        ImplementLoopInitializeOkrTreeCheckitemStateEtcComRespDto implementLoopInitializeOkrTreeCheckitemStateEtcComRespDto = null;
        ImplementLoopInitializeOkrTreeCheckitemStateEtcComReqDto implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto = new ImplementLoopInitializeOkrTreeCheckitemStateEtcComReqDto();
        if (reqDto != null) {
            implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:813718_1
            implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:813719_1
            implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:813720_1
            implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setCreateInductionId(reqDto.getCreateInductionId());//SimpleFieldAssign//sourceId:813721_1
            implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:813722_1
            implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:813723_1
        }

        /*D3执行循环初始化OKR树检查项状态等测试(公共)[6226]   */
        Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getEvaObjTargetCycleCode(), "B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-被评对象目标周期标识不能为空", false);
        Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getEvaObjTypeCode(), "B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-被评对象类型编码不能为空", false);
        Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getEvaluationTemplateId(), "B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getCreateInductionId(), "B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-创建人就职记录ID 不能为空", false);
        Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getSpaceId(), "B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-创建于空间ID不能为空", false);
        Assert.isNull(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto.getAppId(), "B3执行循环初始化OKR树检查项状态等测试（平台）-D3执行循环初始化OKR树检查项状态等测试(公共)-创建于联盟应用ID不能为空", false);
        implementLoopInitializeOkrTreeCheckitemStateEtcComRespDto = fwAppSystemTestDomainClient.implementLoopInitializeOkrTreeCheckitemStateEtcCom(implementLoopInitializeOkrTreeCheckitemStateEtcComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementLoopInitializeOkrTreeCheckitemStateEtcRespDto retData = new BffImplementLoopInitializeOkrTreeCheckitemStateEtcRespDto();


        return retData;
    }

    /**
     * B3执行修正模板执行周期及汇报调度等测试(管理)[7691]
     * gen by moon at 11/4/2023, 3:59:41 PM
     */
    @Trace(operationName = "B3执行修正模板执行周期及汇报调度等测试(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Override
    public BffImplementAmendTempExeCycleAndReportDispatchEtcTestRespDto implementAmendTempExeCycleAndReportDispatchEtcTest(BffImplementAmendTempExeCycleAndReportDispatchEtcTestReqDto reqDto) {


        //步骤0: D3执行修正模板执行周期及汇报调度等测试 - implementAmendTempExeCycleAndReportDispatchEtcTest
        ImplementAmendTempExeCycleAndReportDispatchEtcTestRespDto implementAmendTempExeCycleAndReportDispatchEtcTestRespDto = null;
        ImplementAmendTempExeCycleAndReportDispatchEtcTestReqDto implementAmendTempExeCycleAndReportDispatchEtcTestReqDto = new ImplementAmendTempExeCycleAndReportDispatchEtcTestReqDto();
        if (reqDto != null) {
            implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1238616_1
            implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1238617_1
            implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238618_1
            implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1238619_1
        }

        /*D3执行修正模板执行周期及汇报调度等测试[7692]   */
        Assert.isNull(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.getEvaObjEntityId(), "B3执行修正模板执行周期及汇报调度等测试(管理)-D3执行修正模板执行周期及汇报调度等测试-被评对象内容表主键ID不能为空", false);
        Assert.isNull(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.getEvaObjTypeCode(), "B3执行修正模板执行周期及汇报调度等测试(管理)-D3执行修正模板执行周期及汇报调度等测试-被评对象类型编码不能为空", false);
        Assert.isNull(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.getEvaluationTemplateId(), "B3执行修正模板执行周期及汇报调度等测试(管理)-D3执行修正模板执行周期及汇报调度等测试-冗余评价模板ID不能为空", false);
        Assert.isNull(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto.getSpaceId(), "B3执行修正模板执行周期及汇报调度等测试(管理)-D3执行修正模板执行周期及汇报调度等测试-创建于空间ID不能为空", false);
        implementAmendTempExeCycleAndReportDispatchEtcTestRespDto = fwAppSystemTestDomainClient.implementAmendTempExeCycleAndReportDispatchEtcTest(implementAmendTempExeCycleAndReportDispatchEtcTestReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        BffImplementAmendTempExeCycleAndReportDispatchEtcTestRespDto retData = new BffImplementAmendTempExeCycleAndReportDispatchEtcTestRespDto();


        return retData;
    }
    //
}
